hparticletracksorter.h

Go to the documentation of this file.

//*-- Author : Jochen Markert  18.07.2007

#ifndef  __HPARTICLETRACKSORTER_H__
#define  __HPARTICLETRACKSORTER_H__

#include "hcategory.h"
#include "hiterator.h"
#include "hrecevent.h"
#include "hparticledef.h"

#include <vector>
#include "TString.h"
#include "TFile.h"
#include "TNtuple.h"


using  std::vector;
using  std::iostream;

# define SORTER_NUMBER_OF_INDEX 7
# define SORTER_NUMBER_OF_QUALITY_CRITERIA 7

class HParticleCand;



typedef struct {
    HParticleCand* cand;
    Short_t  ind_Cand;
    Short_t  ind_RICH   ;
    Short_t  ind_innerMDC;
    Short_t  ind_outerMDC;
    Short_t  ind_TOF;
    Short_t  ind_SHOWER;
    Short_t  ind_RPC;
    Short_t  selectedMeta;
    Int_t    nPadsRich;
    Short_t  sec;
    Short_t  MetaModule;
    Short_t  MetaCell;
    Float_t  mom;
    Float_t  beta;
    Float_t  MDC_dEdx;
    Float_t  innerMDCChi2;
    Float_t  outerMDCChi2;
    Short_t  nMdcLayerInnerSeg;
    Short_t  nMdcLayerOuterSeg;
    Float_t  RK_META_match_Quality;
    Float_t  RK_META_match_Radius;
    Float_t  RK_META_dx;
    Float_t  RK_META_dy;
    Float_t  RK_META_match_Shr_Quality;
    Float_t  RK_RICH_match_Quality;
    Float_t  RK_Chi2;
    Bool_t   RICH_RK_Corr;
    Int_t    userSort1;
    Int_t    userSort2;
    Int_t    userSort3;
    Float_t  innerMDCTheta;
    Float_t  innerMDCPhi;
    Float_t  outerMDCTheta;
    Float_t  outerMDCPhi;
} candidateSort;

class sorter_setup : public TObject {

public:

    Int_t kSwitchRICHMatching ;
    Float_t fRICHMDCWindow    ;
    Bool_t kIsFieldOn         ;
    Bool_t kIgnoreRICH        ;
    Bool_t kIgnoreInnerMDC    ;
    Bool_t kIgnoreOuterMDC    ;
    Bool_t kIgnoreMETA        ;
    Bool_t kIgnorePreviousIndex;
    Bool_t (*pUserSort)(candidateSort*, candidateSort*);
    Bool_t kUseYMatching      ;
    Bool_t kUseYMatchingScaling;
    Float_t fMetaBoundary      ;
    Bool_t kUseBeta            ;
    Float_t fBetaLepCut        ;
    Bool_t kUseFakeRejection   ;
    Bool_t kUseMETAQA          ;
    Float_t fMETAQACut         ;
    Float_t fTOFMAXCut         ;
    Float_t fDeltaSegCut       ;

    void setDefault(){

        kSwitchRICHMatching  = Particle::kUseRKRICHWindowSorter;
        fRICHMDCWindow       = 4.;
        kIsFieldOn           = kTRUE;
        kIgnoreRICH          = kFALSE;
        kIgnoreInnerMDC      = kFALSE;
        kIgnoreOuterMDC      = kFALSE;
        kIgnoreMETA          = kFALSE;
        kIgnorePreviousIndex = kFALSE;
        pUserSort            = NULL;
        kUseYMatching        = kTRUE;
        kUseYMatchingScaling = kTRUE;
        fMetaBoundary        = 4.0;
        kUseBeta             = kTRUE;
        fBetaLepCut          = 0.9;
        kUseFakeRejection    = kTRUE;
        kUseMETAQA           = kTRUE;
        fMETAQACut           = 3.0;
        fTOFMAXCut           = 60.0;
        fDeltaSegCut         = 2.0;
    } ;

    void copyFromStatic();
    void copyToStatic();

    void copyFrom(sorter_setup& s){

        kSwitchRICHMatching  = s.kSwitchRICHMatching;
        fRICHMDCWindow       = s.fRICHMDCWindow;
        kIsFieldOn           = s.kIsFieldOn;
        kIgnoreRICH          = s.kIgnoreRICH;
        kIgnoreInnerMDC      = s.kIgnoreInnerMDC;
        kIgnoreOuterMDC      = s.kIgnoreOuterMDC;
        kIgnoreMETA          = s.kIgnoreMETA;
        kIgnorePreviousIndex = s.kIgnorePreviousIndex;
        pUserSort            = s.pUserSort;
        kUseYMatching        = s.kUseYMatching;
        kUseYMatchingScaling = s.kUseYMatchingScaling;
        fMetaBoundary        = s.fMetaBoundary;
        kUseBeta             = s.kUseBeta;
        fBetaLepCut          = s.fBetaLepCut;
        kUseFakeRejection    = s.kUseFakeRejection;
        kUseMETAQA           = s.kUseMETAQA;
        fMETAQACut           = s.fMETAQACut;
        fTOFMAXCut           = s.fTOFMAXCut;
        fDeltaSegCut         = s.fDeltaSegCut;
    };

    void copyTo(sorter_setup& d){

         d.kSwitchRICHMatching  =  kSwitchRICHMatching;
         d.fRICHMDCWindow       =  fRICHMDCWindow;
         d.kIsFieldOn           =  kIsFieldOn;
         d.kIgnoreRICH          =  kIgnoreRICH;
         d.kIgnoreInnerMDC      =  kIgnoreInnerMDC;
         d.kIgnoreOuterMDC      =  kIgnoreOuterMDC;
         d.kIgnoreMETA          =  kIgnoreMETA;
         d.kIgnorePreviousIndex =  kIgnorePreviousIndex;
         d.pUserSort            =  pUserSort;
         d.kUseYMatching        =  kUseYMatching;
         d.kUseYMatchingScaling =  kUseYMatchingScaling;
         d.fMetaBoundary        =  fMetaBoundary;
         d.kUseBeta             =  kUseBeta;
         d.fBetaLepCut          =  fBetaLepCut;
         d.kUseFakeRejection    =  kUseFakeRejection;
         d.kUseMETAQA           =  kUseMETAQA;
         d.fMETAQACut           =  fMETAQACut;
         d.fTOFMAXCut           =  fTOFMAXCut;
         d.fDeltaSegCut         =  fDeltaSegCut;
    };

    void print(){

        cout<<"--------------------------------------------------------------------"<<endl;
        cout<<"sorter_setup:"<<endl;
        cout<<"kSwitchRICHMatching  "<<kSwitchRICHMatching <<endl;
        cout<<"fRICHMDCWindow       "<<fRICHMDCWindow      <<endl;
        cout<<"kIsFieldOn           "<<kIsFieldOn          <<endl;
        cout<<"kIgnoreRICH          "<<kIgnoreRICH         <<endl;
        cout<<"kIgnoreInnerMDC      "<<kIgnoreInnerMDC     <<endl;
        cout<<"kIgnoreOuterMDCB     "<<kIgnoreOuterMDC     <<endl;
        cout<<"kIgnoreMETA          "<<kIgnoreMETA         <<endl;
        cout<<"kIgnorePreviousIndex "<<kIgnorePreviousIndex<<endl;
        cout<<"pUserSort            "<<pUserSort           <<endl;
        cout<<"kUseYMatching        "<<kUseYMatching       <<endl;
        cout<<"kUseYMatchingScaling "<<kUseYMatchingScaling<<endl;
        cout<<"fMetaBoundary        "<<fMetaBoundary       <<endl;
        cout<<"kUseBeta             "<<kUseBeta            <<endl;
        cout<<"fBetaLepCut          "<<fBetaLepCut         <<endl;
        cout<<"kUseFakeRejection    "<<kUseFakeRejection   <<endl;
        cout<<"kUseMETAQA           "<<kUseMETAQA          <<endl;
        cout<<"fMetaBoundary        "<<fMetaBoundary       <<endl;
        cout<<"fMETAQACut           "<<fMETAQACut          <<endl;
        cout<<"fTOFMAXCut           "<<fTOFMAXCut          <<endl;
        cout<<"fDeltaSegCut         "<<fDeltaSegCut        <<endl;
        cout<<"--------------------------------------------------------------------"<<endl;



    }

    ClassDef(sorter_setup,0)

};

class HParticleTrackSorter : public TNamed {

friend class sorter_setup;


public:


protected:

    sorter_setup  setup;                   //!  store copy of setup params local
    sorter_setup  setup_backup;            //!  store a copy of the static setup parameters local to restore them later

    static Bool_t  kDebug;                 //!
    static Int_t   printLevel;             //! higher -> more prints (1,2,3)    (no setup)
    static Int_t   kSwitchIndex;           //! switch to select sort by index    (no setup)
    static Int_t   kSwitchQuality;         //! switch to select sort by quality algorithms  (no setup)
    static Int_t   kSwitchParticle;        //! switch to select leptons/hadrons             (no setup)


    static Int_t   kSwitchRICHMatching;    //! switch to select RICH/MDC matching in lepton selection
    static Float_t fRICHMDCWindow  ;       //! matching window RICH/MDC in phi/theta (symmetric, degree)
    static Bool_t kIsFieldOn;              //! switch selections accoording B-Field
    static Bool_t kIgnoreRICH;             //! switch to ignore RICH hits for Double_t hit counting
    static Bool_t kIgnoreInnerMDC;         //! switch to ignore InnerMDC hits for Double_t hit counting
    static Bool_t kIgnoreOuterMDC;         //! switch to ignore OuterMDC hits for Double_t hit counting
    static Bool_t kIgnoreMETA;             //! switch to ignore META hits for Double_t hit counting
    static Bool_t kIgnorePreviousIndex;    //! switch to ignore indices from previoius marked ued objects
    static Bool_t kUseYMatching;           //! switch to use Y matching to meta cell (default kTRUE)
    static Bool_t kUseYMatchingScaling;    //! switch to use 1/p scaling of Y matching to meta cell (default kTRUE)
    static Bool_t kUseBeta;                //! switch to use Beta (in lepton select use fBetaLepCut, in hadron beta>0) (default kTRUE)
    static Bool_t kUseFakeRejection;       //! switch to use fakerejection in build in select functions  (default kTRUE)
    static Bool_t kUseMETAQA;              //! switch to use metaqa (normed dx) in build in select functions  (default kTRUE)
    static Float_t fMetaBoundary;          //! matching window when using Y matching with metacell [mm] (default 3): fabs(dy) < (halfcell+metaBoundary)
    static Float_t fBetaLepCut;            //! lower beta cut for lepton selection (default 0.9)
    static Float_t fMETAQACut;             //! meta qa (normed dx) cut (default 3.)
    static Float_t fTOFMAXCut;             //! max tof [ns] allowed to match (when beta is used)
    static Float_t fDeltaSegCut;           //! max delta in phi,theta [deg] between inner/outer seg used in B-Field off


    Int_t  fill_Iteration;                 //! remember the number of fill() calls
    Int_t  selectBest_Iteration;           //! remember the number of selectBest() calls
    UInt_t  currentEvent;                   //! find new event

    vector < candidateSort *> all_candidates;  //!

    vector < Int_t > index_RICH;           //!
    vector < Int_t > index_InnerMDC;       //!
    vector < Int_t > index_OuterMDC;       //!
    vector < Int_t > index_SHOWER;         //!
    vector < Int_t > index_TOFHit;         //!
    vector < Int_t > index_TOFClst;        //!
    vector < Int_t > index_RPC;            //!
    vector < Int_t > old_flags;            //! remember the old flags of HParticleCand for restoring
    vector < Int_t > old_flags_emc;        //! remember the old flags of HEmcCluster for restoring

    TString*   nameIndex  ;                //!
    TString*   nameQuality;                //!

    Bool_t     isSimulation;               //!
    TFile*     fout;                       //!
    TNtuple*   nt;                         //!
    HCategory* pParticleCandCat;           //! HParticleCand category
    HCategory* pEmcClusterCat;             //! HEmcCluster category
    HIterator* iterParticleCandCat;        //! iterator on HParticleCand
    HRecEvent* fEvent;                     //! pointer to local event under reconstruction


    static Bool_t (*pUserSort)(candidateSort*, candidateSort*); //! user provided function pointer to sort algo

    void   printCand        (candidateSort*, Int_t, TString spacer = "    ");
    static Bool_t cmpIndex  (candidateSort*, candidateSort*);
    static Bool_t cmpQuality(candidateSort*, candidateSort*);
    Bool_t rejectIndex      (candidateSort*, Particle::ESwitch, Int_t&);
    Bool_t rejectQuality    (candidateSort*, Particle::ESwitch);
    Int_t  flagAccepted     (vector<candidateSort*>&, Particle::ESwitch);
    Int_t  flagDouble       (vector<candidateSort*>&, Particle::ESwitch);
    Int_t  setFlagsDouble   (vector<candidateSort*>&, Particle::ESwitch);
    Int_t  clearVector      (vector<candidateSort*>&);
    Int_t  fillInput        (vector<candidateSort*>&);
    void   selection(Bool_t (*function)(HParticleCand* ));
    Int_t  fillAndSetFlags  ();
    Bool_t flagEmcClusters();
    static Bool_t isDeltaSegOk(HParticleCand*);

    void   clear(void);
public:
    HParticleTrackSorter(void);
    HParticleTrackSorter(TString name,TString title);
    ~HParticleTrackSorter(void);
    Bool_t init     (HRecEvent* evt=0);
    Bool_t finalize (void);
    // setup selections
    static void   setDebug              (Bool_t debug = kTRUE)  { kDebug               = debug;}
    static void   setPrintLevel         (Int_t level)           { printLevel           = level;}

    void   setIsFieldOn          (Bool_t field = kTRUE)  { kIsFieldOn           = field; setup.kIsFieldOn  = field;}
    void   setIgnoreRICH         (Bool_t ignore = kTRUE) { kIgnoreRICH          = ignore;setup.kIgnoreRICH = ignore;}
    void   setIgnoreInnerMDC     (Bool_t ignore = kTRUE) { kIgnoreInnerMDC      = ignore;setup.kIgnoreInnerMDC  = ignore;}
    void   setIgnoreOuterMDC     (Bool_t ignore = kTRUE) { kIgnoreOuterMDC      = ignore;setup.kIgnoreOuterMDC  = ignore;}
    void   setIgnoreMETA         (Bool_t ignore = kTRUE) { kIgnoreMETA          = ignore;setup.kIgnoreMETA      = ignore;}
    void   setIgnorePreviousIndex(Bool_t ignore = kTRUE) { kIgnorePreviousIndex = ignore;setup.kIgnorePreviousIndex = ignore;}
    void   setUseYMatching       (Bool_t use    = kTRUE) { kUseYMatching        = use   ;setup.kUseYMatching        = use   ;}
    void   setUseYMatchingScaling(Bool_t use    = kTRUE) { kUseYMatchingScaling = use   ;setup.kUseYMatchingScaling = use   ;}
    void   setUseBeta            (Bool_t use    = kTRUE) { kUseBeta             = use   ;setup.kUseBeta             = use   ;}
    void   setUseFakeRejection   (Bool_t use    = kTRUE) { kUseFakeRejection    = use   ;setup.kUseFakeRejection    = use   ;}
    void   setUseMETAQA          (Bool_t use    = kTRUE) { kUseMETAQA           = use   ;setup.kUseMETAQA           = use   ;}
    void   setUserSort(Bool_t    (*function)(candidateSort*, candidateSort*)){ pUserSort = function;setup.pUserSort = function;}
    void   setRICHMatching       (Particle::ERichMatch match, Float_t window = 4.);
    void   setMetaBoundary       (Float_t savety = 3.5) { fMetaBoundary = savety;setup.fMetaBoundary = savety;}
    void   setBetaLeptonCut      (Float_t cut = .9)     { fBetaLepCut   = cut;   setup.fBetaLepCut   = cut;}
    void   setMETAQACut          (Float_t cut = 3.)     { fMETAQACut    = cut;   setup.fMETAQACut    = cut;}
    void   setTOFMAXCut          (Float_t cut = 60.)    { fTOFMAXCut    = cut;   setup.fTOFMAXCut    = cut;}
    void   setDeltaSegCut        (Float_t cut = 2.)     { fDeltaSegCut  = cut;   setup.fDeltaSegCut  = cut;}

    Float_t getMetaBoundary()    {return fMetaBoundary;}
    Float_t getBetaLeptonCut()   {return fBetaLepCut;}

    // control selections
    void          resetFlags(Bool_t flag = kTRUE,Bool_t reject = kTRUE,Bool_t used = kTRUE,Bool_t lepton = kTRUE);
    void          cleanUp(Bool_t final = kTRUE);
    Int_t         fill(Bool_t (*function)(HParticleCand* ));
    void          backupFlags(Bool_t onlyFlags=kTRUE);
    Bool_t        restoreFlags(Bool_t onlyFlags=kTRUE);
    void          backupSetup();
    Bool_t        restoreSetup();
    sorter_setup& getSetup(){ return setup; }
    Int_t         selectBest(Particle::ESwitch byQuality, Int_t byParticle);
    static Bool_t selectLeptons          (HParticleCand* pcand = 0);
    static Bool_t selectHadrons          (HParticleCand* pcand = 0);
    static Bool_t selectLeptonsNoOuterFit(HParticleCand* pcand = 0);
    static Bool_t selectHadronsNoOuterFit(HParticleCand* pcand = 0);
    vector < candidateSort *>& getCandidates() { return  all_candidates;}
    void  printEvent(TString comment);
    void  printSetup();
    ClassDef(HParticleTrackSorter,0);
};
#endif /* !__HPARTICLETRACKSORTER_H__ */