#ifndef STNTUPLE_TStnMuonID
#define STNTUPLE_TStnMuonID
///////////////////////////////////////////////////////////////////////////////
// class representing muon ID cuts
// Author:    P. Murat (CDF/FNAL)
// Date:      
///////////////////////////////////////////////////////////////////////////////

#include "TNamed.h"
#include "TString.h"

class  TBuffer;

class TStnMuon;
class TH1F;

class TStnMuonID: public TNamed {
public:
//-----------------------------------------------------------------------------
//  try to keep the same bit numbers as for electrons...
//-----------------------------------------------------------------------------
  enum { 
    kDetectorBit       = 0x1 <<  0,
    kEEmBit            = 0x1 <<  1,
    kEHadBit           = 0x1 <<  2,
    kCmuDelXBit        = 0x1 <<  3,
    kCmpDelXBit        = 0x1 <<  4,
    kCmxDelXBit        = 0x1 <<  5,
    kBmuDelXBit        = 0x1 <<  6,

    kIsoBit            = 0x1 <<  7,
    kIso1Bit           = 0x1 <<  8,
    kTIsoBit           = 0x1 <<  9,

    kTrackPtBit        = 0x1 << 10,
    kCotNAxBit         = 0x1 << 11,
    kCotNStBit         = 0x1 << 12,
    kTrackZ0Bit        = 0x1 << 13,
    kTrackD0Bit        = 0x1 << 14,

    kCmuDelZBit        = 0x1 << 15,
    kCotChi2Bit        = 0x1 << 16,

    kTrackBcPtBit      = 0x1 << 17,

    kLooseTrackPtBit   = 0x1 << 18,
    kLooseEEmBit       = 0x1 << 19,
    kLooseEHadBit      = 0x1 << 20,

    kCmxRhoBit         = 0x1 << 21
  };

  struct Hist_t {
					// tight object cuts
    TH1F*    fDetector    [5];
    TH1F*    fTrackPt     [5];
    TH1F*    fEIso        [5];
    TH1F*    fIso1        [5];
    TH1F*    fEmEnergy    [5];
    TH1F*    fHadEnergy   [5];
    TH1F*    fCmuDelX     [5];
    TH1F*    fCmuDelZ     [5];
    TH1F*    fCmpDelX     [5];
    TH1F*    fCmxDelX     [5];
    TH1F*    fTIso        [5];
    TH1F*    fTrackD0     [5];
    TH1F*    fTrackZ0     [5];
    TH1F*    fCotNAxHits  [5];
    TH1F*    fCotNStHits  [5];
    TH1F*    fTrackBcPt   [5];
					// loose object cuts
    TH1F*    fLooseTrackPt  [5];
    TH1F*    fLooseEmEnergy [5];
    TH1F*    fLooseHadEnergy[5];
					// summary histogram
    TH1F*    fFailedBits;
    TH1F*    fPassed;
  };

protected:
  Int_t      fDetectorMask;
  Int_t      fUseMask;
  Int_t      fInteger[5];       // for future
  Float_t    fMinTrackPt;
  Float_t    fMaxEta;
  Float_t    fMaxEEm;
  Float_t    fMaxEHad;

  Float_t    fMaxCmuDelX;
  Float_t    fMaxCmpDelX;
  Float_t    fMaxCmxDelX;
  Float_t    fMaxBmuDelX;

  Float_t    fMaxCmuDelZ;

  Float_t    fMaxTrackD0;
  Float_t    fMaxTrackZ0;
  Float_t    fMaxCotChi2;

  Float_t    fMaxEIso;
  Float_t    fMaxIso1;
  Float_t    fMaxTIso;
  
  Float_t    fMinNCotAxSeg;
  Float_t    fMinNCotStSeg;

  Float_t    fMinTrackBcPt;

  Float_t    fMinLooseTrackPt;
  Float_t    fMaxLooseEEm;
  Float_t    fMaxLooseEHad;

  Float_t    fMinNCotAxHits;	// min n hits on the segment, added V3
  Float_t    fMinNCotStHits;

  Float_t    fIsoSlope;		// added in V5
  Float_t    fMaxLooseEIso;     // added in V5
  Float_t    fLooseIsoSlope;	// added in V5
  Float_t    fMaxLooseIso1;     // added in V5

  Float_t    fFloat[10];	// spare words, added in V5

  void*      fEOR;		// ! end of record
  int        fCalcNCotSeg;      // ! 1 if nseg needs to be recalculated
//-----------------------------------------------------------------------------
//  methods
//-----------------------------------------------------------------------------
public:
					// ****** constructors and destructor

  TStnMuonID(const char* Name = "Anonymous");
  virtual ~TStnMuonID();
//-----------------------------------------------------------------------------
// accessors
//-----------------------------------------------------------------------------
  Float_t MinTrackPt   () const { return fMinTrackPt;   }
  Float_t MinTrackBcPt () const { return fMinTrackPt;   }
  Float_t MinPt        () const { return fMinTrackPt;   }
  Float_t MaxEEm       () const { return fMaxEEm;       }
  Float_t MaxEHad      () const { return fMaxEHad;      }
  Float_t MaxTrackD0   () const { return fMaxTrackD0;   }
  Float_t MaxTrackZ0   () const { return fMaxTrackZ0;   }
  Float_t MinNCotAxSeg () const { return fMinNCotAxSeg; }
  Float_t MinNCotStSeg () const { return fMinNCotStSeg; }
  Float_t MaxCotChi2   () const { return fMaxCotChi2;   }

  Float_t MinLooseTrackPt() const { return fMinLooseTrackPt; }
  Float_t MaxLooseEEm    () const { return fMaxLooseEEm;     }
  Float_t MaxLooseEHad   () const { return fMaxLooseEHad;    }
  Float_t MaxLooseIso1   () const { return fMaxLooseIso1;    }
  Int_t   UseMask        () const { return fUseMask;         }
  Int_t   CalcNCotSeg    () const { return fCalcNCotSeg;     }
//-----------------------------------------------------------------------------
// modifiers
//-----------------------------------------------------------------------------
  void    SetMaxEEm      (Float_t EEm ) { fMaxEEm       = EEm;  }
  void    SetMaxEHad     (Float_t EHad) { fMaxEHad      = EHad; }
  void    SetMaxEIso     (Float_t E   ) { fMaxEIso      = E;    }
  void    SetIsoSlope    (Float_t Slope) { fIsoSlope     = Slope;}

  void    SetMaxIso1     (Float_t Iso1) { fMaxIso1      = Iso1; }
  void    SetMaxTIso     (Float_t TIso) { fMaxTIso      = TIso; }
  void    SetMinTrackPt  (Float_t Pt  ) { fMinTrackPt   = Pt;   }
  void    SetMinTrackBcPt(Float_t Pt  ) { fMinTrackBcPt = Pt;   }
  void    SetMaxTrackD0  (Float_t D0  ) { fMaxTrackD0   = D0;   }
  void    SetMaxTrackZ0  (Float_t Z0  ) { fMaxTrackZ0   = Z0;   }
  void    SetMaxCotChi2  (Float_t Chi2) { fMaxCotChi2   = Chi2; }

  void    SetMinNCotAxHits(Int_t   N    ) { fMinNCotAxHits = N;     } 
  void    SetMinNCotStHits(Int_t   N    ) { fMinNCotStHits = N;     } 
  void    SetMinNCotAxSeg (Int_t   N    ) { fMinNCotAxSeg  = N;     } 
  void    SetMinNCotStSeg (Int_t   N    ) { fMinNCotStSeg  = N;     } 

  void    SetMinLooseTrackPt(Float_t Pt  ) { fMinLooseTrackPt = Pt;   }
  void    SetMaxLooseEEm    (Float_t EEm ) { fMaxLooseEEm     = EEm;  }
  void    SetMaxLooseEHad   (Float_t EHad) { fMaxLooseEHad    = EHad; }
  void    SetMaxLooseIso1   (Float_t Iso1) { fMaxLooseIso1    = Iso1; }
  void    SetMaxLooseEIso   (Float_t EIso ) { fMaxLooseEIso    = EIso; }
  void    SetLooseIsoSlope  (Float_t Slope) { fLooseIsoSlope   = Slope;}

  void    SetUseMask        (Int_t   Mask) { fUseMask         = Mask; }
  void    SetCalcNCotSeg    (Int_t   Flag) { fCalcNCotSeg     = Flag; }
//-----------------------------------------------------------------------------
// other methods
//-----------------------------------------------------------------------------
  virtual Int_t  IDWord     (TStnMuon* Muon);
  virtual Int_t  TightIDWord(TStnMuon* Muon);
  virtual Int_t  LooseIDWord(TStnMuon* Muon);

  void FillHistograms(Hist_t& Hist, TStnMuon* Muo);
//-----------------------------------------------------------------------------
//  overloaded methods of TObject
//-----------------------------------------------------------------------------
  void  Print  (Option_t* Option = "") const ;
//-----------------------------------------------------------------------------
//  schema evolution
//  2009-12-24: current version - V5
//-----------------------------------------------------------------------------
  void  ReadV1(TBuffer& R__b);
  void  ReadV2(TBuffer& R__b);
  void  ReadV3(TBuffer& R__b);
  void  ReadV4(TBuffer& R__b);

  ClassDef(TStnMuonID,5)

};

#endif