FairEvtFilterOnSingleParticleCounts.h

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----             FairEvtFilterOnSingleParticleCounts header file                 -----
// -------------------------------------------------------------------------


#ifndef FairEvtFilterOnSingleParticleCounts_H_
#define FairEvtFilterOnSingleParticleCounts_H_

#include "FairEvtFilter.h"
#include "TParticle.h"
#include "TMath.h"
#include<map>
#include<vector>
#include<iostream>


typedef std::map<Int_t, std::vector<Int_t> >  PdgGroupId;
typedef std::pair<Int_t,std::vector<Int_t> > PdgGroupIdPair;
typedef std::map<Int_t,std::vector<Int_t> >::iterator PdgGroupIdIterator;

std::ostream& operator <<(std::ostream& os, const std::vector<Int_t>& v);
std::ostream& operator <<(std::ostream& os, const std::vector< std::pair<Double_t, Double_t> >& vpair);
std::ostream& operator <<(std::ostream& os, const std::vector< std::pair<Int_t, Int_t> >& vpair);
std::ostream& operator <<(std::ostream& os, const std::map<Int_t, std::vector<Int_t> >& PdgGroupId);


class FairEvtFilterOnSingleParticleCounts : public FairEvtFilter
{

public:

        //Default constructor
        FairEvtFilterOnSingleParticleCounts();

        //Constructor with name and title
        FairEvtFilterOnSingleParticleCounts(const char* name, const char* title="FairEvtFilterOnSingleParticleCounts");

        // Destructor
        virtual ~FairEvtFilterOnSingleParticleCounts();

        // User interfaces -- Pdg Code Min and Max
        // Use this for grouping up to 8 pdgCodes into 1 groupId
        // all particles belonging to the groupId are regarded as being indistinguishable
        // min defines how many particles you want in your events AT LEAST
        // max defines how many particles you want in your events AT MOST
        // the min and max numbers are used for all particles with one of the above pdgCodes
        // returns kTRUE if the filter was added, otherwise returns kFALSE
        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 );


        // use if you want to group more than 8 pdgCodes into 1 groupId
        // all particles belonging to the groupId are regarded as being indistinguishable
        // min defines how many particles you want in your events AT LEAST
        // max defines how many particles you want in your events AT MOST
        // the min and max numbers are used for all particles with pdgCodes in the vector pdgCodes
        // returns kTRUE if the filter was added, otherwise returns kFALSE
        // all entries containing invalidPdgCode in the pdgCodes vector are skipped (as there is no pdgCode invalidPdgCode)
        Bool_t AndMinMaxPdgCodes( Int_t min, Int_t max, std::vector<Int_t> &pdgCodes );


        // User interfaces -- Pdg Code Min only
        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){
                return AndMinMaxPdgCodes( min, 9999, pdgCode1, pdgCode2, pdgCode3, pdgCode4, pdgCode5, pdgCode6, pdgCode7, pdgCode8  );
        };
        Bool_t AndMinPdgCodes(Int_t min, std::vector<Int_t> &pdgCodes ){
                return AndMinMaxPdgCodes( min, 9999, pdgCodes );
        };


        // User interfaces -- Pdg Code Max only
        Bool_t AndMaxPdgCodes(Int_t max, std::vector<Int_t> &pdgCodes ){
                return AndMinMaxPdgCodes( 0, max, 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){
                return AndMinMaxPdgCodes( 0, max, pdgCode1, pdgCode2, pdgCode3, pdgCode4, pdgCode5, pdgCode6, pdgCode7, pdgCode8 );
        };


        // User interfaces -- Charge
        // min defines how many particles you want in your events AT LEAST
        // max defines how many particles you want in your events AT MOST
        // Use for setting multiplicity constraints based on particle charges
        // ChargeState
        // kNeutral - neutral particles
        // kPlus - positively charged particles
        // kMinus - negatively charged particles
        // kCharged - positively or negatively charged particles
        // kAll - all particles (neutral or charged)
        Bool_t AndMinMaxCharge( Int_t min, Int_t max, ChargeState charge );


        //use the methods above with fixed minimum or maximum number of particles
        Bool_t AndMinCharge(Int_t min, ChargeState charge){return AndMinMaxCharge( min, 9999, charge);};
        Bool_t AndMaxCharge(Int_t max, ChargeState charge){return AndMinMaxCharge( 0, max, charge);};


        // User interfaces -- All particles in event
        // Use if you want to put constraints on the number of particles in the event
        // Functionality is implemented in AndMinMaxCharge
        Bool_t AndMinMaxAllParticles(Int_t min, Int_t max){ return AndMinMaxCharge(min, max, kAll); };


        //use the methods above with fixed minimum or maximum number of particles
        Bool_t AndMinAllParticles(Int_t min){ return AndMinMaxCharge( min, 9999, kAll); };
        Bool_t AndMaxAllParticles(Int_t max){ return AndMinMaxCharge( 0, max, kAll); };


        // User interfaces -- Momentum constraints
        //use if you want to consider particles which fulfill certain momentum constraints
        //could be used in combination with any other filter, if you want to set momentum limits for several particles
        Bool_t AndPRange(Double_t min, Double_t max){return AndMinMaxMom( min, max, kMomTotal);};
        Bool_t AndPtRange(Double_t min, Double_t max){return AndMinMaxMom( min, max, kMomTrans);};
        Bool_t AndPzRange(Double_t min, Double_t max){return AndMinMaxMom( min, max, kMomZ);};


        // User interfaces -- Angular constraints
        //use if you want to consider particles in certain angle or vertex ranges
        //could be used in combination with any other filter, if you want to set geometric limits for several particles
        Bool_t AndThetaRange(Double_t min, Double_t max){return AndMinMaxGeom( min, max, kTheta);};
        Bool_t AndPhiRange(Double_t min, Double_t max){return AndMinMaxGeom( min, max, kPhi);};


        // User interfaces -- Vertex constraints
        //use if you want to consider particles in certain angle or vertex ranges
        //could be used in combination with any other filter, if you want to set geometric limits for several particles
        Bool_t AndVzRange(Double_t min, Double_t max){return AndMinMaxGeom( min, max, kVertexZ);};
        Bool_t AndRhoRange(Double_t min, Double_t max){return AndMinMaxGeom( min, max, kVertexRho);};
        Bool_t AndRadiusRange(Double_t min, Double_t max){return AndMinMaxGeom( min, max, kVertexRadius);};


        // checks if the particles in the event (fParticleList) suit the filter settings
        // kTRUE if event matches, kFALSE otherwise
        Bool_t EventMatches(Int_t evtNr);


        // returns kTRUE if the filter on pdg codes or charge states (or all particles) is turned on
        // Momentum and angular constraints do not play any role here
        Bool_t FilterActive(){
                return ( fFilterPdg || fFilterCharge );
        };


private:
        // in these methods the functions of the user interfaces from above are realized
        // all user interfaces are only calling this two methods with different arguments
        Bool_t AndMinMaxMom(Double_t min, Double_t max, MomState mom);
        Bool_t AndMinMaxGeom(Double_t min, Double_t max, GeomState geom);


        // initialize the counters for pdg codes or charge states
        void InitCounters();


        // Set default boundaries for momenta, angles and vertices
        // that are always fulfilled
        // this implements the default case of not filtering on momenta, angles or vertices
        void SetDefaultBoundaries();


        // count up the appropriate element of fCountCharge
        void CountCharge(TParticle* particle);
        // count up the appropriate element of fCountGroupId
        void CountPdg(TParticle* particle);

        // check whether the particle fulfills the momentum constraints
        Bool_t AcceptMomentum(TParticle* particle);
        // check whether the particle fulfills the geometry constraints
        Bool_t AcceptGeometry(TParticle* particle);

        // check whether the event satisfies the constraints on pdg multiplicities (fCountGroupId vector has to be filled already)
        Bool_t AcceptPdgCounter();
        //check whether the event satisfies the constraints on charge state multiplicities (fCountCharge vector has to be filled already)
        Bool_t AcceptChargeCounter();


        // first input = pdg code (as used by event generators)
        // second input = "vector of group IDs that the pdg code is assigned to"
        // one pdg code can be assigned to mutliple group IDs
        // all pdg codes within the same group ID are treated as indistinguishable
        // group IDs are automatically assigned; they are not known to the user and have to start with 0 and be consecutive as they are used as the index for fPartCounts
        PdgGroupId fPdgGroupId;

        // for counting the multiplicities based on group IDs
        std::vector<Int_t> fCountGroupId;
        // for counts the multiplicities based on electrical charge
        std::vector<Int_t> fCountCharge;


        // vector defining the minimum and maximum acceptable multiplicities for each group ID
        std::vector< std::pair<Int_t,Int_t> > fGroupIdCountsMinMax;
        // vector containing the minimum and maximum acceptable multiplicities for each electrical charge state
        // check ChargeState in FairEvtFilter.h for translating the index to an electrical charge
        std::vector< std::pair<Int_t,Int_t> > fChargeCountsMinMax;


        // only particles with a momentum within the min and max value will be counted
        // check MomState in FairEvtFilter.h for translating the index to an electrical charge
        std::vector< std::pair<Double_t,Double_t> > fMomMinMax;
        // only particles with angles and vertices within the min and max value will be counted
        // check GeomState in FairEvtFilter.h for translating the index to an electrical charge
        std::vector< std::pair<Double_t,Double_t> > fGeomMinMax;


        Bool_t fFilterPdg; 
        Bool_t fFilterCharge; 
        Bool_t fFilterMom; 
        Bool_t fFilterGeom; 


        static const Int_t kInvalidPdgCode = 0;


        ClassDef(FairEvtFilterOnSingleParticleCounts,1);

};


#endif /* FairEvtFilterOnSingleParticleCounts_H_ */