LegsCut

class LegsCut : public TNamed

    private:

              LegsCut()
         void InitCut()
         void SetNbPionCut()
         void SetNbProtonCut()
         void SetNbXtPionCut()
         void SetNbXtProtonCut()
         void SetPnPionCut()
         void SetPnProtonCut()
         void SetXtPionCut()
         void SetXtProtonCut()

    public:

                                                                                                                                                LegsCut(const LegsCut&)
                                                                                                                                        virtual ~LegsCut()
                                                                                                                                 static TClass* Class()
                                                                                                            const map<string,vector<Float_t> >* GetCutMap() const
      map<string,vector<float,allocator<float> >,less<string>,allocator<pair<const string,vector<float,allocator<float> > > > >::const_iterator GetIterator(const string& cutName)
                                                                                                                                static LegsCut* Instance()
                                                                                                                                virtual TClass* IsA() const
                                                                                                                                           bool IsNbNeutral(const Float_t& nvdE)
                                                                                                                                           bool IsNbPion(const Float_t& E, const Float_t& dE)
                                                                                                                                           bool IsNbProton(const Float_t& E, const Float_t& dE)
                                                                                                                                           bool IsNbXtPion(const Float_t& E, const Float_t& dE)
                                                                                                                                           bool IsNbXtProton(const Float_t& E, const Float_t& dE)
                                                                                                                                           bool IsPbGamma(Int_t partIndex)
                                                                                                                                           bool IsPnGamma(const Float_t& InvBeta)
                                                                                                                                           bool IsPnNeutron(const Float_t& InvBeta)
                                                                                                                                           bool IsPnPion(const Float_t& E, const Float_t& dE)
                                                                                                                                           bool IsPnPion(const Float_t& InvBeta)
                                                                                                                                           bool IsPnProton(const Float_t& E, const Float_t& dE)
                                                                                                                                           bool IsPnProton(const Float_t& InvBeta)
                                                                                                                                           bool IsPnProton(Int_t partIndex)
                                                                                                                                           bool IsXtGamma(Int_t partIndex)
                                                                                                                                           bool IsXtPiMinus(Int_t partIndex)
                                                                                                                                           bool IsXtPion(const Float_t& E, const Float_t& dE)
                                                                                                                                           bool IsXtPiPlus(Int_t partIndex)
                                                                                                                                           bool IsXtProton(const Float_t& E, const Float_t& dE)
                                                                                                                                       LegsCut& operator=(const LegsCut&)
                                                                                                                                   virtual void ShowMembers(TMemberInspector& insp, char* parent)
                                                                                                                                   virtual void Streamer(TBuffer& b)
                                                                                                                                           void StreamerNVirtual(TBuffer& b)
                                                                                                                                           void UpdateCut(const Int_t& time, const string& cutName)

Data Members

    private:

                   static LegsCut* fInstance         
        map<string,vector<Int_t> > fCutTimeMap       
                 map<string,Int_t> fCutTimeIndexMap  
      map<string,vector<Float_t> > fCutMap           
              LegsAccessorToolKit* fAccessorToolKit  
                            TCutG* fXtProtonCut      
                            TCutG* fXtPionCut        
                            TCutG* fNbProtonCut      
                            TCutG* fNbPionCut        
                            TCutG* fNbXtProtonCut    
                            TCutG* fNbXtPionCut      
                            TCutG* fPnProtonCut      
                            TCutG* fPnPionCut        

Class Description

 constructor of the class

 initialize all vectors with cut times from Cuts/cuts.db
 the file needs to be updated manually every time new cuts are added with
 help of program UpdateCutsDB.cxx

 updates cut vectors in fCutTimeMap map based on available
 cut files.  The files must have a certain format (specified
 below). When new files are added to the directory Cut they must be
 scanned by program UpdateCutsDB ( available in directory
 programs), which creates list in cuts.db. That list is used by
 LegsEvent to determine when to stop and to read in next file. New
 cut files will be available to LegEvent only if they are in cuts.db.

 define and set the proton cut on E-dE histograms for the Xtal box

 do the test if data pair E-dE is inside the proton region

 define and set the charged pion cut on E-dE histograms for the Xtal box

 do the test if data pair E-dE is inside the pion region

 define and set the proton cut on E-dE histograms for the n-barrel

 do the test if data pair E-dE is inside the proton region

 define and set the charged pion cut on E-dE histograms for the n-barrel

 do the test if data pair E-dE is inside the pion region

 define and set the proton cut on added E-dE histograms for the Xtal box and n-barrel

 do the test if data pair E-dE is inside the proton region

 define and set the charged pion cut on added E-dE histograms for the Xtal box and n-barrel

 do the test if data pair E-dE is inside the pion region

 define and set the proton cut on E-dE histograms for the Xtal box

 do the test if data pair E-dE is inside the proton region

 define and set the proton cut on E-dE histograms for the Xtal box

 do the test if data pair E-dE is inside the pion region

 do the test if particle in n-barrel is neutral by checking that Nv is lower than
 a certain energy

 do the test if inverse beta is inside the cut region

 do the test if inverse beta is inside the cut region

 do the test if inverse beta is inside the cut region

 do the test if inverse beta is inside the cut region

 XT && !XV for the XVface or XC && !XV at neigbour XV faces

 one cluster in PB , nothing in PN  in same direction as cluster in PB

Inline Functions

                                       void ~LegsCut()
        const map<string,vector<Float_t> >* GetCutMap() const
                                    TClass* Class()
                                    TClass* IsA() const
                                       void ShowMembers(TMemberInspector& insp, char* parent)
                                       void Streamer(TBuffer& b)
                                       void StreamerNVirtual(TBuffer& b)
                                    LegsCut LegsCut(const LegsCut&)
                                   LegsCut& operator=(const LegsCut&)