FairEvtFilterOnSingleParticleCounts Class Reference

#include <FairEvtFilterOnSingleParticleCounts.h>

Inheritance diagram for FairEvtFilterOnSingleParticleCounts:

Public Types
enum	ChargeState {   kNeutral =0, kPlus, kMinus, kCharged,   kAll, kChargeLastElement }
enum	MomState { kMomTotal =0, kMomTrans, kMomZ, kMomLastElement }
enum	GeomState {   kTheta =0, kPhi, kVertexZ, kVertexRho,   kVertexRadius, kGeomLastElement }
enum	LogicOp { kAnd =0, kOr, kLogicOpLastElement }

Public Member Functions
	FairEvtFilterOnSingleParticleCounts ()
	FairEvtFilterOnSingleParticleCounts (const char *name, const char *title="FairEvtFilterOnSingleParticleCounts")
virtual	~FairEvtFilterOnSingleParticleCounts ()
Bool_t	AndMinMaxPdgCodes (Int_t min, Int_t max, Int_t pdgCode1, Int_t pdgCode2=kInvalidPdgCode, Int_t pdgCode3=kInvalidPdgCode, Int_t pdgCode4=kInvalidPdgCode, Int_t pdgCode5=kInvalidPdgCode, Int_t pdgCode6=kInvalidPdgCode, Int_t pdgCode7=kInvalidPdgCode, Int_t pdgCode8=kInvalidPdgCode)
Bool_t	AndMinMaxPdgCodes (Int_t min, Int_t max, std::vector< Int_t > &pdgCodes)
Bool_t	AndMinPdgCodes (Int_t min, Int_t pdgCode1, Int_t pdgCode2=kInvalidPdgCode, Int_t pdgCode3=kInvalidPdgCode, Int_t pdgCode4=kInvalidPdgCode, Int_t pdgCode5=kInvalidPdgCode, Int_t pdgCode6=kInvalidPdgCode, Int_t pdgCode7=kInvalidPdgCode, Int_t pdgCode8=kInvalidPdgCode)
Bool_t	AndMinPdgCodes (Int_t min, std::vector< Int_t > &pdgCodes)
Bool_t	AndMaxPdgCodes (Int_t max, std::vector< Int_t > &pdgCodes)
Bool_t	AndMaxPdgCodes (Int_t max, Int_t pdgCode1, Int_t pdgCode2=kInvalidPdgCode, Int_t pdgCode3=kInvalidPdgCode, Int_t pdgCode4=kInvalidPdgCode, Int_t pdgCode5=kInvalidPdgCode, Int_t pdgCode6=kInvalidPdgCode, Int_t pdgCode7=kInvalidPdgCode, Int_t pdgCode8=kInvalidPdgCode)
Bool_t	AndMinMaxCharge (Int_t min, Int_t max, ChargeState charge)
Bool_t	AndMinCharge (Int_t min, ChargeState charge)
Bool_t	AndMaxCharge (Int_t max, ChargeState charge)
Bool_t	AndMinMaxAllParticles (Int_t min, Int_t max)
Bool_t	AndMinAllParticles (Int_t min)
Bool_t	AndMaxAllParticles (Int_t max)
Bool_t	AndPRange (Double_t min, Double_t max)
Bool_t	AndPtRange (Double_t min, Double_t max)
Bool_t	AndPzRange (Double_t min, Double_t max)
Bool_t	AndThetaRange (Double_t min, Double_t max)
Bool_t	AndPhiRange (Double_t min, Double_t max)
Bool_t	AndVzRange (Double_t min, Double_t max)
Bool_t	AndRhoRange (Double_t min, Double_t max)
Bool_t	AndRadiusRange (Double_t min, Double_t max)
Bool_t	EventMatches (Int_t evtNr)
Bool_t	FilterActive ()
Bool_t	SetListOfParticles (TClonesArray *ParticleList)
void	PrintAllTParticleInEvent ()
Bool_t	Init ()
void	SetVerbose (Int_t verbose=12)
void	ShowAcceptedEventNumbers ()
void	ShowEvtNrsToAccept ()
void	SetTestMode (Int_t *arrayPtr, Int_t nEntries)
Bool_t	TestPassed ()
Bool_t	GetCharge (Int_t inPdgCode, Double_t *pdgCodeCharge)

Protected Attributes
TDatabasePDG *	fdbPdg
TClonesArray *	fParticleList
Int_t	fVerbose
Bool_t	fTestMode
std::set< Int_t >	fAcceptedEventNumbers
std::set< Int_t >	fEvtNrsToAccept
Int_t	fEventNr

Static Protected Attributes
static const Double_t	kNoChargeSpecified = -999.9

Private Member Functions
Bool_t	AndMinMaxMom (Double_t min, Double_t max, MomState mom)
Bool_t	AndMinMaxGeom (Double_t min, Double_t max, GeomState geom)
void	InitCounters ()
void	SetDefaultBoundaries ()
void	CountCharge (TParticle *particle)
void	CountPdg (TParticle *particle)
Bool_t	AcceptMomentum (TParticle *particle)
Bool_t	AcceptGeometry (TParticle *particle)
Bool_t	AcceptPdgCounter ()
Bool_t	AcceptChargeCounter ()
	ClassDef (FairEvtFilterOnSingleParticleCounts, 1)

Private Attributes
PdgGroupId	fPdgGroupId
std::vector< Int_t >	fCountGroupId
std::vector< Int_t >	fCountCharge
std::vector< std::pair< Int_t, Int_t > >	fGroupIdCountsMinMax
std::vector< std::pair< Int_t, Int_t > >	fChargeCountsMinMax
std::vector< std::pair < Double_t, Double_t > >	fMomMinMax
std::vector< std::pair < Double_t, Double_t > >	fGeomMinMax
Bool_t	fFilterPdg
	is kTRUE if any pdg / group ID filter is set More...
Bool_t	fFilterCharge
	is kTRUE if any filter on electrical charge is set (also kTRUE if filter on the total number of particles is set - charge state kAll) More...
Bool_t	fFilterMom
	is kTRUE if any momentum filter is set More...
Bool_t	fFilterGeom
	is kTRUE if any geometry filter is set More...

Static Private Attributes
static const Int_t	kInvalidPdgCode = 0
	constant holding an integer number which is not used as a pdg code this serves as a place holder when constructing a vector from integers given by the user More...

Detailed Description

Definition at line 56 of file FairEvtFilterOnSingleParticleCounts.h.

Member Enumeration Documentation

enum FairEvtFilter::ChargeState

inherited

Enumerator
kNeutral
kPlus
kMinus
kCharged
kAll
kChargeLastElement

Definition at line 39 of file FairEvtFilter.h.

{ kNeutral=0, kPlus, kMinus, kCharged, kAll, kChargeLastElement };

enum FairEvtFilter::GeomState

inherited

Enumerator
kTheta
kPhi
kVertexZ
kVertexRho
kVertexRadius
kGeomLastElement

Definition at line 41 of file FairEvtFilter.h.

{kTheta=0, kPhi, kVertexZ, kVertexRho, kVertexRadius, kGeomLastElement};

enum FairEvtFilter::LogicOp

inherited

Enumerator
kAnd
kOr
kLogicOpLastElement

Definition at line 42 of file FairEvtFilter.h.

{ kAnd=0, kOr, kLogicOpLastElement };

enum FairEvtFilter::MomState

inherited

Enumerator
kMomTotal
kMomTrans
kMomZ
kMomLastElement

Definition at line 40 of file FairEvtFilter.h.

{ kMomTotal=0, kMomTrans, kMomZ, kMomLastElement};

Constructor & Destructor Documentation

FairEvtFilterOnSingleParticleCounts::FairEvtFilterOnSingleParticleCounts

(

)

Definition at line 88 of file FairEvtFilterOnSingleParticleCounts.cxx.

References SetDefaultBoundaries().

                                                                         : 
                FairEvtFilter(" ", "FairEvtFilterOnSingleParticleCounts"), fFilterPdg(kFALSE),fFilterCharge(kFALSE),
                fFilterMom(kFALSE),fFilterGeom(kFALSE)
{
        SetDefaultBoundaries();
}

FairEvtFilterOnSingleParticleCounts::FairEvtFilterOnSingleParticleCounts	(	const char *	name,
		const char *	title = "FairEvtFilterOnSingleParticleCounts"
	)

Definition at line 97 of file FairEvtFilterOnSingleParticleCounts.cxx.

References SetDefaultBoundaries().

: FairEvtFilter(name, title),fFilterPdg(kFALSE),  fFilterCharge(kFALSE),
  fFilterMom(kFALSE),fFilterGeom(kFALSE)
{
        SetDefaultBoundaries();
}

FairEvtFilterOnSingleParticleCounts::~FairEvtFilterOnSingleParticleCounts ( )

virtual

Definition at line 123 of file FairEvtFilterOnSingleParticleCounts.cxx.

{}

Member Function Documentation

Bool_t FairEvtFilterOnSingleParticleCounts::AcceptChargeCounter ( )

private

Definition at line 466 of file FairEvtFilterOnSingleParticleCounts.cxx.

References fChargeCountsMinMax, fCountCharge, FairEvtFilter::fVerbose, and FairEvtFilter::kChargeLastElement.

Referenced by EventMatches().

{       // check if event matches the filter
        // event matches if
        // fCountCharge[icountPdg] >= fChargeCountsMinMax[icountPdg].first
        // and
        // fCountCharge[icountPdg] <= fChargeCountsMinMax[icountPdg].second
        for (UInt_t icountCharge = 0; icountCharge < FairEvtFilter::kChargeLastElement; ++icountCharge){
                if ( fCountCharge[icountCharge] < fChargeCountsMinMax[icountCharge].first){
                        if (fVerbose >9){
                                std::cout << "Event does not match filter because of fCountCharge[icountChart] < fChargeCountMinMax[icountCharge].first for icountCharge == " << icountCharge << "\n";
                        }
                        return kFALSE;
                }
                if ( fCountCharge[icountCharge] > fChargeCountsMinMax[icountCharge].second ){
                        if (fVerbose >9){
                                std::cout << "Event does not match filter because of fCountCharge[icountCharge] > fChargeCountsMinMax[icountCharge].second for icountCharge == " << icountCharge << "\n";
                        }
                        return kFALSE;
                }
        }
        return kTRUE;
}

Bool_t FairEvtFilterOnSingleParticleCounts::AcceptGeometry ( TParticle *  particle )

private

Definition at line 390 of file FairEvtFilterOnSingleParticleCounts.cxx.

References Double_t, fGeomMinMax, FairEvtFilter::fVerbose, geom(), FairEvtFilter::kGeomLastElement, FairEvtFilter::kPhi, FairEvtFilter::kTheta, FairEvtFilter::kVertexRadius, FairEvtFilter::kVertexRho, FairEvtFilter::kVertexZ, and Pi.

Referenced by EventMatches().

{
        if (fVerbose > 9){
                std::cout << "{ Theta , Phi , Vz, VRho, VRadius }: { " << particle->Theta()*180./TMath::Pi() << ", " << particle->Phi()*180./TMath::Pi();
                std::cout << ", " << particle->Vz() << ", " << particle->Rho() << ", " << particle->R()<< " }\n";
        }

        Double_t geom;
        std::string type;
        for(UInt_t iGeom=0; iGeom < FairEvtFilter::kGeomLastElement; iGeom++){//check every geometry constraint for the considered particle
                switch(iGeom){
                case kTheta:
                        geom=particle->Theta();
                        type="Theta";
                        break;
                case kPhi:
                        geom=particle->Phi();
                        type="Phi";
                        break;
                case kVertexZ:
                        geom=particle->Vz();
                        type="Vz";
                        break;
                case kVertexRho:
                        geom=particle->Rho();
                        type="VRho";
                        break;
                case kVertexRadius:
                        geom=particle->R();
                        type="VRadius";
                        break;
                default:
                        std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Check your filter calls!\n\n\n";
                        return kFALSE;
                }
                if ( geom < fGeomMinMax[iGeom].first){
                        if (fVerbose >9){
                                std::cout << "Set GeomOk to kFALSE because of " << type << " < And" << type << "Range() minimum." << "\n";
                        }
                        return kFALSE;
                }
                if ( geom > fGeomMinMax[iGeom].second ){
                        if (fVerbose >9){
                                std::cout << "Set GeomOk to kFALSE because of " << type << " > And" << type << "Range() maximum." << "\n";
                        }
                        return kFALSE;
                }
        }
        return kTRUE;
}

Bool_t FairEvtFilterOnSingleParticleCounts::AcceptMomentum ( TParticle *  particle )

private

Definition at line 347 of file FairEvtFilterOnSingleParticleCounts.cxx.

References Double_t, fMomMinMax, FairEvtFilter::fVerbose, FairEvtFilter::kMomLastElement, FairEvtFilter::kMomTotal, FairEvtFilter::kMomTrans, and FairEvtFilter::kMomZ.

Referenced by EventMatches().

{
        if (fVerbose > 9){
                std::cout << "{ P , Pt , Pz }: { " << particle->P() << ", " << particle->Pt() << ", " << particle->Pz() << " }\n";
        }

        Double_t momentum;
        std::string type;
        for(UInt_t iMom=0; iMom < FairEvtFilter::kMomLastElement; iMom++){//check every momentum constraint for the considered particle
                switch(iMom){
                case kMomTotal:
                        momentum=particle->P();
                        type="P";
                        break;
                case kMomTrans:
                        momentum=particle->Pt();
                        type="Pt";
                        break;
                case kMomZ:
                        momentum=particle->Pz();
                        type="Pz";
                        break;
                default:
                        std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Check your filter calls!\n\n\n";
                        return kFALSE;
                        if ( momentum < fMomMinMax[iMom].first){
                                if (fVerbose >9){
                                        std::cout << "Set MomOk to kFALSE because of " << type << "< And" << type << "Range() minimum." << "\n";
                                }
                                return kFALSE;
                        }
                        if ( momentum > fMomMinMax[iMom].second ){
                                if (fVerbose >9){
                                        std::cout << "Set MomOk to kFALSE because of " << type << " > And" << type << "Range() maximum." << "\n";
                                }
                                return kFALSE;
                        }
                }
        }
        return kTRUE;
}

Bool_t FairEvtFilterOnSingleParticleCounts::AcceptPdgCounter ( )

private

Definition at line 442 of file FairEvtFilterOnSingleParticleCounts.cxx.

References fCountGroupId, fGroupIdCountsMinMax, and FairEvtFilter::fVerbose.

Referenced by EventMatches().

{       // check if event matches the filter
        // event matches if
        // fCountGroupId[icountPdg] >= fGroupIdCountsMinMax[icountPdg].first
        // and
        // fCountGroupId[icountPdg] <= fGroupIdCountsMinMax[icountPdg].second
        for (UInt_t icountPdg = 0; icountPdg < fCountGroupId.size(); ++icountPdg){
                if ( fCountGroupId[icountPdg] < fGroupIdCountsMinMax[icountPdg].first){
                        if (fVerbose >9){
                                std::cout << "Event does NOT match filter because of fCountGroupId[icountPdg] < fGroupIdCountMinMax[icountPdg].first for icountPdg == " << icountPdg << "\n";
                        }
                        return kFALSE;
                }
                if ( fCountGroupId[icountPdg] > fGroupIdCountsMinMax[icountPdg].second ){
                        if (fVerbose >9){
                                std::cout << "Event does NOT match filter because of fCountGroupId[icountPdg] > fGroupIdCountsMinMax[icountPdg].second for icountPdg == " << icountPdg << "\n";
                        }
                        return kFALSE;
                }
        }
        return kTRUE;
}

Bool_t FairEvtFilterOnSingleParticleCounts::AndMaxAllParticles ( Int_t  max )

inline

Definition at line 144 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxCharge(), and FairEvtFilter::kAll.

{ return AndMinMaxCharge( 0, max, kAll); };

Bool_t FairEvtFilterOnSingleParticleCounts::AndMaxCharge ( Int_t  max, ChargeState  charge  )

inline

Definition at line 131 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxCharge().

{return AndMinMaxCharge( 0, max, charge);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndMaxPdgCodes ( Int_t  max, std::vector< Int_t > &  pdgCodes  )

inline

Definition at line 106 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxPdgCodes().

Referenced by prod_fsim().

                                                                     {
                return AndMinMaxPdgCodes( 0, max, pdgCodes );
        };

Bool_t FairEvtFilterOnSingleParticleCounts::AndMaxPdgCodes ( Int_t  max, Int_t  pdgCode1, Int_t  pdgCode2 = kInvalidPdgCode, Int_t  pdgCode3 = kInvalidPdgCode, Int_t  pdgCode4 = kInvalidPdgCode, Int_t  pdgCode5 = kInvalidPdgCode, Int_t  pdgCode6 = kInvalidPdgCode, Int_t  pdgCode7 = kInvalidPdgCode, Int_t  pdgCode8 = kInvalidPdgCode  )

inline

Definition at line 109 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxPdgCodes().

                                                                                                                                                                                                                                                                                        {
                return AndMinMaxPdgCodes( 0, max, pdgCode1, pdgCode2, pdgCode3, pdgCode4, pdgCode5, pdgCode6, pdgCode7, pdgCode8 );
        };

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinAllParticles ( Int_t  min )

inline

Definition at line 143 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxCharge(), and FairEvtFilter::kAll.

{ return AndMinMaxCharge( min, 9999, kAll); };

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinCharge ( Int_t  min, ChargeState  charge  )

inline

Definition at line 130 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxCharge().

Referenced by prod_fsim().

{return AndMinMaxCharge( min, 9999, charge);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinMaxAllParticles ( Int_t  min, Int_t  max  )

inline

Definition at line 139 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxCharge(), and FairEvtFilter::kAll.

Referenced by sim_filter_ex2().

{ return AndMinMaxCharge(min, max, kAll); };

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinMaxCharge	(	Int_t	min,
		Int_t	max,
		ChargeState	charge
	)

Definition at line 218 of file FairEvtFilterOnSingleParticleCounts.cxx.

References fChargeCountsMinMax, fFilterCharge, FairEvtFilter::fVerbose, max(), and min().

Referenced by AndMaxAllParticles(), AndMaxCharge(), AndMinAllParticles(), AndMinCharge(), and AndMinMaxAllParticles().

{

        if (fVerbose > 0){
                std::cout << this->GetTitle() << ": " << this->GetName() << "\n";
                std::cout << "fChargeCountsMinMax: " << fChargeCountsMinMax << "\n\n";
        }

        // check if filter can be applied (make sure that min and max make sense)
        if ( min < 0 ){
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Filter could not be added. You are trying to request that your events should have at least a number <= 0 of some particles. That makes no sense. Check your AndMinMaxCharge calls!\n\n\n";
                return kFALSE;
        }
        if ( max < min ){
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Filter could not be added. You are trying to request that your events should have at most a number of some particles which is less than the minimum number that you request. That makes no sense. Check your AndMinMaxCharge calls!\n\n\n";
                return kFALSE;
        }

        // saving the lower and upper limit of particle multiplicities for the corresponding ChargeState in fChargeCountsMinMax
        fChargeCountsMinMax[charge]=std::pair<Int_t, Int_t> (min,max);

        // turn filter on
        fFilterCharge=kTRUE;

        if (fVerbose > 0){
                std::cout << "FairEvtFilterOnSingleParticleCounts: After adding ChargeFilter:\n";
                std::cout << "fGroupIdCountsMinMax: " << fChargeCountsMinMax << "\n\n";
        }
        return kTRUE;
}

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinMaxGeom ( Double_t  min, Double_t  max, FairEvtFilter::GeomState  geom  )

private

Definition at line 282 of file FairEvtFilterOnSingleParticleCounts.cxx.

References fFilterGeom, fGeomMinMax, FairEvtFilter::fVerbose, geom(), max(), min(), and Pi.

Referenced by AndPhiRange(), AndRadiusRange(), AndRhoRange(), AndThetaRange(), and AndVzRange().

{

        if (fVerbose > 0){
                std::cout << this->GetTitle() << ": " << this->GetName() << "\n";
                std::cout << "fGeomMinMax { Theta , Phi, VertexZ, VertexRho, VertexRadius }: " << fGeomMinMax << "\n\n";
        }

        // check if filter can be applied (make sure that min and max make sense)
        if ( min < 0 ){
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Filter could not be added. You are trying to request that your events should have at least a number <= 0 of some particles. Check your AndMinMaxGeom calls.\n\n\n";
                return kFALSE;
        }
        if ( max < min ){
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Filter could not be added. You are trying to request that your events should have at most a number of some particles which is less than the minimum number that you request. Check your AndMinMaxGeom calls.\n\n\n";
                return kFALSE;
        }

        if(geom==0 || geom==1){
                min=min*2*(TMath::Pi())/360;
                max=max*2*(TMath::Pi())/360;
        }

        // saving the lower and upper limit for the corresponding GeomState in fGeomMinMax
        fGeomMinMax[geom]=std::pair<Double_t, Double_t> (min,max);


        // turn filter on
        fFilterGeom=kTRUE;

        if (fVerbose > 0){
                std::cout << "FairEvtFilterOnSingleParticleCounts: After adding GeomFilter:\n";
                std::cout << "fGeomMinMax { Theta , Phi, VertexZ, VertexRho, VertexRadius }: " << fGeomMinMax << "\n\n";
        }

        return kTRUE;
}

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinMaxMom ( Double_t  min, Double_t  max, FairEvtFilter::MomState  mom  )

private

Definition at line 250 of file FairEvtFilterOnSingleParticleCounts.cxx.

References fFilterMom, fMomMinMax, FairEvtFilter::fVerbose, max(), min(), and mom.

Referenced by AndPRange(), AndPtRange(), and AndPzRange().

{

        if (fVerbose > 0){
                std::cout << this->GetTitle() << ": " << this->GetName() << "\n";
                std::cout << "fMomMinMax { P , Pt , Pz }: " << fMomMinMax << "\n\n";
        }

        // check if filter can be applied (make sure that min and max make sense)
        if ( min < 0 ){
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Filter could not be added. You are trying to request that your events should have at least a number <= 0 of some particles. Check your AndMinMaxMom calls.\n\n\n";
                return kFALSE;
        }
        if ( max < min ){
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Filter could not be added. You are trying to request that your events should have at most a number of some particles which is less than the minimum number that you request. Check your AndMinMaxMom calls.\n\n\n";
                return kFALSE;
        }

        // saving the lower and upper limit for the corresponding MomState in fMomMinMax
        fMomMinMax[mom]=std::pair<Double_t, Double_t> (min,max);

        // turn filter on
        fFilterMom=kTRUE;

        if (fVerbose > 0){
                std::cout << "FairEvtFilterOnSingleParticleCounts: After adding MomFilter:\n";
                std::cout << "fMomMinMax { P , Pt , Pz }: " << fMomMinMax << "\n\n";
        }
        return kTRUE;
}

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinMaxPdgCodes	(	Int_t	min,
		Int_t	max,
		Int_t	pdgCode1,
		Int_t	pdgCode2 = kInvalidPdgCode,
		Int_t	pdgCode3 = kInvalidPdgCode,
		Int_t	pdgCode4 = kInvalidPdgCode,
		Int_t	pdgCode5 = kInvalidPdgCode,
		Int_t	pdgCode6 = kInvalidPdgCode,
		Int_t	pdgCode7 = kInvalidPdgCode,
		Int_t	pdgCode8 = kInvalidPdgCode
	)

Definition at line 126 of file FairEvtFilterOnSingleParticleCounts.cxx.

Referenced by AndMaxPdgCodes(), AndMinPdgCodes(), and sim_filter_ex2().

{
        // construct a vector pdgCodes containing all pdg codes given by caller
        // and call the general AndMinMaxPdgCodes method
        std::vector<Int_t> pdgCodes;
        pdgCodes.push_back(pdgCode1);
        pdgCodes.push_back(pdgCode2);
        pdgCodes.push_back(pdgCode3);
        pdgCodes.push_back(pdgCode4);
        pdgCodes.push_back(pdgCode5);
        pdgCodes.push_back(pdgCode6);
        pdgCodes.push_back(pdgCode7);
        pdgCodes.push_back(pdgCode8);

        return AndMinMaxPdgCodes( min, max, pdgCodes );
}

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinMaxPdgCodes	(	Int_t	min,
		Int_t	max,
		std::vector< Int_t > &	pdgCodes
	)

Definition at line 144 of file FairEvtFilterOnSingleParticleCounts.cxx.

References Bool_t, fFilterPdg, fGroupIdCountsMinMax, finder, fPdgGroupId, FairEvtFilter::fVerbose, and kInvalidPdgCode.

{
        // was adding of the filter successful
        Bool_t filterAdded = kFALSE;

        if (fVerbose > 0){
                std::cout << this->GetTitle() << ": " << this->GetName() << "\n";
                std::cout << "fPdgGroupId: " << fPdgGroupId << "\n";
                std::cout << "fGroupIdCountsMinMax: " << fGroupIdCountsMinMax << "\n\n";
        }


        // check if filter can be applied (make sure that min and max make sense)
        if ( min < 0 ){
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Filter could not be added. You are trying to request that your events should have at least a number <= 0 of some particles. That makes no sense. Check your AndMinMaxPdgCodes calls!\n\n\n";
                return kFALSE;
        }
        if ( max < min ){
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Filter could not be added. You are trying to request that your events should have at most a number of some particles which is less than the minimum number that you request. That makes no sense. Check your AndMinMaxPdgCodes calls!\n\n\n";
                return kFALSE;
        }

        // find the groupId for the pdgCodes
        // the current pdgCodes are appended to the pre-existing vector
        Int_t newGroupId = fGroupIdCountsMinMax.size();

        // for every entry in pdgCodes
        // -- save a new entry in the map fPdgGroupId if the entry is not already in map
        // -- add a new groupId to the vector in fPdgGroupId if the entry already exists in the map

        for (UInt_t iPdgCodes = 0; iPdgCodes < pdgCodes.size(); ++iPdgCodes){
                // skip kInvalidPdgCode entries in pdgCodes
                if ( kInvalidPdgCode != pdgCodes[iPdgCodes] ) {
                        // check if map has already an entry for the pdgCode
                        PdgGroupIdIterator finder = fPdgGroupId.find(pdgCodes[iPdgCodes]);
                        if ( fPdgGroupId.end() != finder){
                                // pdgCode is already in map, add groupId to vector

                                std::vector<Int_t> & groupIdVector = fPdgGroupId[pdgCodes[iPdgCodes]];
                                groupIdVector.push_back(newGroupId);
                        }
                        else {
                                // pdgCode is not in map yet, create new entry of Int_t and vector<Int_t>

                                std::vector<Int_t> groupIdVector;
                                groupIdVector.push_back(newGroupId);
                                fPdgGroupId.insert(PdgGroupIdPair(pdgCodes[iPdgCodes],groupIdVector));
                        }

                        filterAdded = kTRUE;
                }
        }

        if ( kTRUE == filterAdded ){
                // set the minimum and maximum number of particles for the current groupId
                fGroupIdCountsMinMax.push_back(std::pair<Int_t, Int_t> (min,max));

        } else {
                std::cout << "\n\n\n  -WARNING from FairEvtFilterOnSingleParticleCounts: Tried to add filter, but that was not possible as all pdg codes were kInvalidPdgCode!\n\n\n";
                return kFALSE;
        }

        // turn filter on
        fFilterPdg = kTRUE;

        if (fVerbose > 0){
                std::cout << "FairEvtFilterOnSingleParticleCounts: After adding PdgFilter:\n";
                std::cout << "fPdgGroupId: " << fPdgGroupId << "\n";
                std::cout << "fGroupIdCountsMinMax: " << fGroupIdCountsMinMax << "\n\n";
        }
        return kTRUE;
}

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinPdgCodes ( Int_t  min, Int_t  pdgCode1, Int_t  pdgCode2 = kInvalidPdgCode, Int_t  pdgCode3 = kInvalidPdgCode, Int_t  pdgCode4 = kInvalidPdgCode, Int_t  pdgCode5 = kInvalidPdgCode, Int_t  pdgCode6 = kInvalidPdgCode, Int_t  pdgCode7 = kInvalidPdgCode, Int_t  pdgCode8 = kInvalidPdgCode  )

inline

Definition at line 95 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxPdgCodes().

Referenced by quickfsimana().

                                                                                                                                                                                                                                                                                        {
                return AndMinMaxPdgCodes( min, 9999, pdgCode1, pdgCode2, pdgCode3, pdgCode4, pdgCode5, pdgCode6, pdgCode7, pdgCode8  );
        };

Bool_t FairEvtFilterOnSingleParticleCounts::AndMinPdgCodes ( Int_t  min, std::vector< Int_t > &  pdgCodes  )

inline

Definition at line 98 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxPdgCodes().

                                                                     {
                return AndMinMaxPdgCodes( min, 9999, pdgCodes );
        };

Bool_t FairEvtFilterOnSingleParticleCounts::AndPhiRange ( Double_t  min, Double_t  max  )

inline

Definition at line 163 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxGeom(), and FairEvtFilter::kPhi.

{return AndMinMaxGeom( min, max, kPhi);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndPRange ( Double_t  min, Double_t  max  )

inline

Definition at line 152 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxMom(), and FairEvtFilter::kMomTotal.

{return AndMinMaxMom( min, max, kMomTotal);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndPtRange ( Double_t  min, Double_t  max  )

inline

Definition at line 153 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxMom(), and FairEvtFilter::kMomTrans.

{return AndMinMaxMom( min, max, kMomTrans);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndPzRange ( Double_t  min, Double_t  max  )

inline

Definition at line 154 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxMom(), and FairEvtFilter::kMomZ.

{return AndMinMaxMom( min, max, kMomZ);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndRadiusRange ( Double_t  min, Double_t  max  )

inline

Definition at line 173 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxGeom(), and FairEvtFilter::kVertexRadius.

{return AndMinMaxGeom( min, max, kVertexRadius);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndRhoRange ( Double_t  min, Double_t  max  )

inline

Definition at line 172 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxGeom(), and FairEvtFilter::kVertexRho.

{return AndMinMaxGeom( min, max, kVertexRho);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndThetaRange ( Double_t  min, Double_t  max  )

inline

Definition at line 162 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxGeom(), and FairEvtFilter::kTheta.

{return AndMinMaxGeom( min, max, kTheta);};

Bool_t FairEvtFilterOnSingleParticleCounts::AndVzRange ( Double_t  min, Double_t  max  )

inline

Definition at line 171 of file FairEvtFilterOnSingleParticleCounts.h.

References AndMinMaxGeom(), and FairEvtFilter::kVertexZ.

{return AndMinMaxGeom( min, max, kVertexZ);};

FairEvtFilterOnSingleParticleCounts::ClassDef ( FairEvtFilterOnSingleParticleCounts  , 1    )

private

void FairEvtFilterOnSingleParticleCounts::CountCharge ( TParticle *  particle )

private

Definition at line 517 of file FairEvtFilterOnSingleParticleCounts.cxx.

References Double_t, fCountCharge, FairEvtFilter::fVerbose, FairEvtFilter::GetCharge(), FairEvtFilter::kAll, FairEvtFilter::kCharged, FairEvtFilter::kMinus, FairEvtFilter::kNeutral, and FairEvtFilter::kPlus.

Referenced by EventMatches().

                                                                        {
        // get pdg code for particle
        Int_t partPdg = particle->GetPdgCode();


        // get charge for pdg code
        Double_t pdgCodeCharge = 0;
        if ( kFALSE == GetCharge( partPdg, &pdgCodeCharge ) ) {
                // skip particles of unknown charge
                return;
        }


        // Based on charge increment the according entry in fChargeCountsMinMax
        if(pdgCodeCharge!=0){
                fCountCharge[FairEvtFilter::kCharged]++;
                if(pdgCodeCharge>0){
                        fCountCharge[FairEvtFilter::kPlus]++;
                }else{
                        fCountCharge[FairEvtFilter::kMinus]++;
                }
        }else{
                fCountCharge[FairEvtFilter::kNeutral]++;
        }
        fCountCharge[FairEvtFilter::kAll]++;

        if (fVerbose >9){
                std::cout << "Charge:" << pdgCodeCharge << "    ->    " << "fCountCharge: " << fCountCharge << "\n";
        }
}

void FairEvtFilterOnSingleParticleCounts::CountPdg ( TParticle *  particle )

private

Definition at line 490 of file FairEvtFilterOnSingleParticleCounts.cxx.

References fCountGroupId, fPdgGroupId, and FairEvtFilter::fVerbose.

Referenced by EventMatches().

                                                                     {
        // every restriction that is placed on a pdg code is described by a groupId
        // one groupId can belong to several particles assuming that they are indistinguishable
        // fPdgGroupId contains all the user defined constraints on particles with certain pdg codes organized in a map
        // all elements in this map have the pdg code as first entry and a vector of groupId's as second entry
        // if there exists an entry for the considered particle in the map the appropriate entry of fCountGroupId is counted up
        //  whereat the associated groupId's are exactly representing the index of the incremented fCountGroupId vector

        // get pdg code for particle
        Int_t partPdg = particle->GetPdgCode();

        // check if the pdg code is contained in some groupId
        PdgGroupIdIterator it = fPdgGroupId.find(partPdg);
        if ( fPdgGroupId.end() != it ){
                // pdg code was found
                std::vector<Int_t> groupIdVector = it->second;
                for (size_t iGroupId = 0; iGroupId < groupIdVector.size(); ++iGroupId){
                        ++fCountGroupId[groupIdVector[iGroupId]];
                }
        }

        if (fVerbose >9){
                std::cout << "partPdg:" << partPdg << "    ->    " << "fCountGroupId: " << fCountGroupId << "\n";
        }
}

Bool_t FairEvtFilterOnSingleParticleCounts::EventMatches ( Int_t  evtNr )

virtual

Implements FairEvtFilter.

Definition at line 549 of file FairEvtFilterOnSingleParticleCounts.cxx.

References AcceptChargeCounter(), AcceptGeometry(), AcceptMomentum(), AcceptPdgCounter(), Bool_t, CountCharge(), CountPdg(), FairEvtFilter::fAcceptedEventNumbers, fChargeCountsMinMax, fCountCharge, fCountGroupId, fFilterCharge, fFilterGeom, fFilterMom, fFilterPdg, fGeomMinMax, fGroupIdCountsMinMax, fMomMinMax, FairEvtFilter::fParticleList, fPdgGroupId, FairEvtFilter::fVerbose, InitCounters(), particle, and FairEvtFilter::PrintAllTParticleInEvent().

{
        if (fVerbose > 3){
                std::cout << "\n\n";
                std::cout << "Generated event: " << evtNr << "\n";
                std::cout << "FairEvtFilterOnSingleParticleCounts: " << this->GetTitle() << ": " << this->GetName() << " Beginning of EventMatches\n";
                std::cout << "Nr. of simulated particles: " << fParticleList->GetEntries()<<"\n";
                PrintAllTParticleInEvent();
                std::cout << "fPdgGroupId: " << fPdgGroupId << "\n";
                std::cout << "fGroupIdCountsMinMax: " << fGroupIdCountsMinMax << "\n";
                std::cout << "fChargeCountsMinMax: " << fChargeCountsMinMax << "\n";
                std::cout << "fMomMinMax: " << fMomMinMax << "\n";
                std::cout << "fGeomMinMax: " << fGeomMinMax << "\n";
        }


        // Not necessary as FairFilteredPrimaryGenerator already checks this
        //      // event matches if filter is not set
        //      if ( kFALSE == FilterActive() ) {
        //              return kTRUE;
        //      }


        // sanity checks
        if (0==fParticleList){
                std::cout << "\n\n\n FairEvtFilterOnSingleParticleCounts: FATAL ERROR: No particle list! Event does not match.\n\n\n";
                return kFALSE;
        }

        if (0==fParticleList->GetEntriesFast()){
                std::cout << "\n\n\n FairEvtFilterOnSingleParticleCounts: Event contains 0 particles. Event does not match.\n\n\n";
                return kFALSE;
        }

        // reset all counters for each new event
        InitCounters();


        // loop the produced particles and count up
        // the specified "groupIDs"
        // and charge states
        // for particles which satisfy the momentum, angular and vertex constraints
        for (Int_t iPart= 0; iPart< fParticleList->GetEntries(); iPart++) {

                TParticle* particle=(TParticle*)fParticleList->At(iPart);
                if (0 == particle) { continue; }

                // check whether the particle satisfies the momentum constraints
                if(fFilterMom){
                        if(!AcceptMomentum(particle)){ continue; } // if the particle doesn't suit the momentum filter settings go ahead to the next particle
                }

                // check whether the particle satisfies the geometric constraints
                if(fFilterGeom){
                        if(!AcceptGeometry(particle)){ continue; } // if the particle doesn't suit the geometric filter settings go ahead to the next particle
                }

                // count up the appropriate element of fCountGroupId and fCountCharge
                // important: Do not count before all of the above tests were passed!
                if(fFilterPdg){
                        CountPdg(particle);
                }
                if(fFilterCharge){
                        CountCharge(particle);
                }

        }// end of the loop over all particles

        // reset PdgOk and ChargeOk to kTRUE for each new event
        // for checking if event matches
        Bool_t PdgOk= kTRUE;
        Bool_t ChargeOk = kTRUE;

        if (fVerbose >9){
                std::cout << "\n Check if event matches the filter \n";
                std::cout << "fCountGroupId: " << fCountGroupId << "\n";
                std::cout <<  "fGroupIdCountsMinMax: " << fGroupIdCountsMinMax << "\n";
                std::cout << "fCountCharge: " << fCountCharge << "\n";
                std::cout <<  "fChargeCountsMinMax: " << fChargeCountsMinMax << "\n";
        }


        if(fFilterPdg){
                PdgOk=AcceptPdgCounter();
        }

        if(fFilterCharge){
                ChargeOk=AcceptChargeCounter();
        }

        // event matches if pdg and charges are ok
        Bool_t evtOk=PdgOk && ChargeOk;

        if ( kTRUE == evtOk ) {
                fAcceptedEventNumbers.insert(evtNr); // for QA
        }

        if (fVerbose >5){
                if ( kTRUE == evtOk ) {
                        std::cout << "\n Event matches " << this->GetTitle() << ": " << this->GetName() << "\n\n";
                } else {
                        std::cout << "\n Event does NOT match " << this->GetTitle() << ": " << this->GetName() << "\n\n";
                }
        }
        return evtOk;
}

Bool_t FairEvtFilterOnSingleParticleCounts::FilterActive ( )

inlinevirtual

Implements FairEvtFilter.

Definition at line 183 of file FairEvtFilterOnSingleParticleCounts.h.

References fFilterCharge, and fFilterPdg.

                             {
                return ( fFilterPdg || fFilterCharge );
        };

Bool_t FairEvtFilter::GetCharge ( Int_t  inPdgCode, Double_t *  pdgCodeCharge  )

inherited

Definition at line 62 of file FairEvtFilter.cxx.

References FairEvtFilter::fdbPdg, FairEvtFilter::fVerbose, and FairEvtFilter::kNoChargeSpecified.

Referenced by CountCharge(), PndEvtFilter::FillList(), and PndEvtFilterOnInvMassCounts::SetPdgCodesToCombine().

{
        // Try to find the pdg code
        TParticlePDG *ptrToPdg = fdbPdg->GetParticle(inPdgCode);
        if ( 0 == ptrToPdg) {
                // ignore particles with unknown charges
                std::cout << "WARNING from FairEvtFilter::GetCharge Charge of pdgCode " << inPdgCode << " is unknown and will be ignored!\n";
                *pdgCodeCharge = kNoChargeSpecified;
                return kFALSE;
        }
        *pdgCodeCharge = ptrToPdg->Charge()/3.; // TParticlePDG contains charge in units of |e|/3
        if ( fVerbose > 1 ) std::cout << "Found pdgCodeCharge = " << *pdgCodeCharge << " for inPdgCode " << inPdgCode << '\n';
        return kTRUE;
}

Bool_t FairEvtFilter::Init ( )

inlineinherited

Definition at line 64 of file FairEvtFilter.h.

Referenced by FairFilteredPrimaryGenerator::Init().

{ return kTRUE;}

void FairEvtFilterOnSingleParticleCounts::InitCounters ( )

private

Definition at line 321 of file FairEvtFilterOnSingleParticleCounts.cxx.

References fCountCharge, fCountGroupId, fGroupIdCountsMinMax, FairEvtFilter::fVerbose, and FairEvtFilter::kChargeLastElement.

Referenced by EventMatches().

{
        // initialize a 0 fCountGroupId of same size as fGroupIdCountsMinMax
        fCountGroupId.clear();
        for (UInt_t icountPdg = 0; icountPdg < fGroupIdCountsMinMax.size(); ++icountPdg){
                fCountGroupId.push_back(0);
        }

        // fCountGroupId counts up, event matches if all entries in fCountGroupId are between the according entries in fGroupIdCountsMinMax
        if (fVerbose >11){
                std::cout << "fCountGroupId after initialization: " << fCountGroupId << "\n";
        }

        // initialize a 0 fCountCharge of same size as fChargeCountsMinMax
        fCountCharge.clear();
        for (UInt_t icountCharge = 0; icountCharge < FairEvtFilter::kChargeLastElement; ++icountCharge){
                fCountCharge.push_back(0);
        }

        // fCountCharge counts up, event matches if all entries in fCountCharge are between the according entries in fChargeCountsMinMax
        if (fVerbose >11){
                std::cout << "fCountCharge after initialization: " << fCountCharge << "\n";
        }
}

void FairEvtFilter::PrintAllTParticleInEvent ( )

inherited

Definition at line 52 of file FairEvtFilter.cxx.

References FairEvtFilter::fParticleList, and particle.

Referenced by PndEvtFilterOnInvMassCounts::EventMatches(), and EventMatches().

                                            {
        // sanity checks
        if (0==fParticleList){ return; }
        for (Int_t iPart=0; iPart<fParticleList->GetEntries(); ++iPart) {
                TParticle *particle = (TParticle*)fParticleList->At(iPart);
                particle->Print();
        }
}

void FairEvtFilterOnSingleParticleCounts::SetDefaultBoundaries ( )

private

Definition at line 105 of file FairEvtFilterOnSingleParticleCounts.cxx.

References fChargeCountsMinMax, fGeomMinMax, fMomMinMax, FairEvtFilter::kChargeLastElement, FairEvtFilter::kGeomLastElement, and FairEvtFilter::kMomLastElement.

Referenced by FairEvtFilterOnSingleParticleCounts().

                                                              {
        // initialize a default fChargeCountsMinMax with kChargeLastElement entries
        for (UInt_t icount = 0; icount < FairEvtFilter::kChargeLastElement; ++icount){
                fChargeCountsMinMax.push_back(std::pair<Int_t, Int_t> (0,99999));
        }

        // initialize a default fMomMinMax with kMomLastElement entries
        for (UInt_t icount = 0; icount < FairEvtFilter::kMomLastElement; ++icount){
                fMomMinMax.push_back(std::pair<Double_t, Double_t> (-99999.,99999.));
        }

        // initialize a default fGeomMinMax with kGeomLastElement entries
        for (UInt_t icount = 0; icount < FairEvtFilter::kGeomLastElement; ++icount){
                fGeomMinMax.push_back(std::pair<Double_t, Double_t> (-99999.,99999.));
        }
}

Bool_t FairEvtFilter::SetListOfParticles ( TClonesArray *  ParticleList )

inlineinherited

Definition at line 57 of file FairEvtFilter.h.

References FairEvtFilter::fParticleList.

Referenced by FairFilteredPrimaryGenerator::GenerateEvent().

{fParticleList=ParticleList; return kTRUE;};

void FairEvtFilter::SetTestMode ( Int_t *  arrayPtr, Int_t  nEntries  )

inlineinherited

Definition at line 91 of file FairEvtFilter.h.

References FairEvtFilter::fEvtNrsToAccept, and FairEvtFilter::fTestMode.

                                                         {
                //turns on the test mode with the declared fEvtNrsToAccept
                fTestMode=kTRUE;
                std::set<Int_t> evtNrsToAccept (arrayPtr,arrayPtr+nEntries);
                fEvtNrsToAccept=evtNrsToAccept;
        }

void FairEvtFilter::SetVerbose ( Int_t  verbose = 12 )

inlineinherited

Definition at line 67 of file FairEvtFilter.h.

References FairEvtFilter::fVerbose, and verbose.

Referenced by sim_filter_inv_mass().

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

void FairEvtFilter::ShowAcceptedEventNumbers ( )

inlineinherited

Definition at line 77 of file FairEvtFilter.h.

References FairEvtFilter::fAcceptedEventNumbers.

                                       {
                // for QA
                // shows fAcceptedEventNumbers that is filled after running a simulation
                std::cout << "\n fAcceptedEventNumbers" << " = " << fAcceptedEventNumbers;
        }

void FairEvtFilter::ShowEvtNrsToAccept ( )

inlineinherited

Definition at line 84 of file FairEvtFilter.h.

References FairEvtFilter::fEvtNrsToAccept.

                                 {
                // for QA
                //shows fEvtNrsToAccept that has to be set if you want to run your simulation in test mode
                std::cout << "\n fEvtNrsToAccept" << " = " << fEvtNrsToAccept;
        }

Bool_t FairEvtFilter::TestPassed ( )

inlineinherited

Definition at line 99 of file FairEvtFilter.h.

References FairEvtFilter::fAcceptedEventNumbers, FairEvtFilter::fEvtNrsToAccept, and FairEvtFilter::fTestMode.

                           {
                if(kFALSE==fTestMode){
                        std::cout << "\n\n\n WARNING from FairEvtFilter: Test mode not set.\n\n\n";
                        return kFALSE;
                }
                if(fAcceptedEventNumbers==fEvtNrsToAccept){
                        //std::cout << "\n\n\n FairEvtFilter: Test passed.\n\n\n";
                        return kTRUE;
                }else{
                        //std::cout << "\n\n\n FairEvtFilter: Test failed. Check your SetTestMode calls. \n\n\n";
                        return kFALSE;
                }
        }

Member Data Documentation

std::set<Int_t> FairEvtFilter::fAcceptedEventNumbers

protectedinherited

Definition at line 134 of file FairEvtFilter.h.

Referenced by PndEvtFilterOnInvMassCounts::EventMatches(), EventMatches(), FairEvtFilter::FairEvtFilter(), FairEvtFilter::ShowAcceptedEventNumbers(), and FairEvtFilter::TestPassed().

std::vector< std::pair<Int_t,Int_t> > FairEvtFilterOnSingleParticleCounts::fChargeCountsMinMax

private

Definition at line 238 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AcceptChargeCounter(), AndMinMaxCharge(), EventMatches(), and SetDefaultBoundaries().

std::vector<Int_t> FairEvtFilterOnSingleParticleCounts::fCountCharge

private

Definition at line 231 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AcceptChargeCounter(), CountCharge(), EventMatches(), and InitCounters().

std::vector<Int_t> FairEvtFilterOnSingleParticleCounts::fCountGroupId

private

Definition at line 229 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AcceptPdgCounter(), CountPdg(), EventMatches(), and InitCounters().

TDatabasePDG* FairEvtFilter::fdbPdg

protectedinherited

Definition at line 126 of file FairEvtFilter.h.

Referenced by PndEvtFilterOnInvMassCounts::EventMatches(), FairEvtFilter::FairEvtFilter(), PndEvtFilter::FillList(), and FairEvtFilter::GetCharge().

Int_t FairEvtFilter::fEventNr

protectedinherited

Definition at line 136 of file FairEvtFilter.h.

std::set<Int_t> FairEvtFilter::fEvtNrsToAccept

protectedinherited

Definition at line 135 of file FairEvtFilter.h.

Referenced by FairEvtFilter::SetTestMode(), FairEvtFilter::ShowEvtNrsToAccept(), and FairEvtFilter::TestPassed().

Bool_t FairEvtFilterOnSingleParticleCounts::fFilterCharge

private

is kTRUE if any filter on electrical charge is set (also kTRUE if filter on the total number of particles is set - charge state kAll)

Definition at line 250 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AndMinMaxCharge(), EventMatches(), and FilterActive().

Bool_t FairEvtFilterOnSingleParticleCounts::fFilterGeom

private

is kTRUE if any geometry filter is set

Definition at line 252 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AndMinMaxGeom(), and EventMatches().

Bool_t FairEvtFilterOnSingleParticleCounts::fFilterMom

private

is kTRUE if any momentum filter is set

Definition at line 251 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AndMinMaxMom(), and EventMatches().

Bool_t FairEvtFilterOnSingleParticleCounts::fFilterPdg

private

is kTRUE if any pdg / group ID filter is set

Definition at line 249 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AndMinMaxPdgCodes(), EventMatches(), and FilterActive().

std::vector< std::pair<Double_t,Double_t> > FairEvtFilterOnSingleParticleCounts::fGeomMinMax

private

Definition at line 246 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AcceptGeometry(), AndMinMaxGeom(), EventMatches(), and SetDefaultBoundaries().

std::vector< std::pair<Int_t,Int_t> > FairEvtFilterOnSingleParticleCounts::fGroupIdCountsMinMax

private

Definition at line 235 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AcceptPdgCounter(), AndMinMaxPdgCodes(), EventMatches(), and InitCounters().

std::vector< std::pair<Double_t,Double_t> > FairEvtFilterOnSingleParticleCounts::fMomMinMax

private

Definition at line 243 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AcceptMomentum(), AndMinMaxMom(), EventMatches(), and SetDefaultBoundaries().

TClonesArray* FairEvtFilter::fParticleList

protectedinherited

Definition at line 131 of file FairEvtFilter.h.

Referenced by PndEvtFilterOnInvMassCounts::EventMatches(), EventMatches(), FairEvtFilter::FairEvtFilter(), PndEvtFilter::FillList(), FairEvtFilter::PrintAllTParticleInEvent(), and FairEvtFilter::SetListOfParticles().

PdgGroupId FairEvtFilterOnSingleParticleCounts::fPdgGroupId

private

Definition at line 226 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AndMinMaxPdgCodes(), CountPdg(), and EventMatches().

Bool_t FairEvtFilter::fTestMode

protectedinherited

Definition at line 133 of file FairEvtFilter.h.

Referenced by FairEvtFilter::SetTestMode(), and FairEvtFilter::TestPassed().

Int_t FairEvtFilter::fVerbose

protectedinherited

Definition at line 132 of file FairEvtFilter.h.

Referenced by AcceptChargeCounter(), AcceptGeometry(), AcceptMomentum(), AcceptPdgCounter(), AndMinMaxCharge(), AndMinMaxGeom(), AndMinMaxMom(), AndMinMaxPdgCodes(), CountCharge(), CountPdg(), PndEvtFilterOnInvMassCounts::EventMatches(), EventMatches(), FairEvtFilter::GetCharge(), InitCounters(), and FairEvtFilter::SetVerbose().

const Int_t FairEvtFilterOnSingleParticleCounts::kInvalidPdgCode = 0

staticprivate

constant holding an integer number which is not used as a pdg code this serves as a place holder when constructing a vector from integers given by the user

Definition at line 257 of file FairEvtFilterOnSingleParticleCounts.h.

Referenced by AndMinMaxPdgCodes().

const Double_t FairEvtFilter::kNoChargeSpecified = -999.9

staticprotectedinherited

Definition at line 129 of file FairEvtFilter.h.

Referenced by PndEvtFilter::FillList(), FairEvtFilter::GetCharge(), and PndEvtFilterOnInvMassCounts::SetPdgCodesToCombine().

---

The documentation for this class was generated from the following files:

• FairEvtFilterOnSingleParticleCounts.h
• FairEvtFilterOnSingleParticleCounts.cxx