#if !defined (__CINT__) || defined (__MAKECINT__)

#include "TH1.h"
#include "TH2.h"
#include "TProfile.h"

#include <Stntuple/loop/TStnModule.hh>

#include <Stntuple/obj/TStnTauBlock.hh>
#include <Stntuple/obj/TStnTrackBlock.hh>
#include <Stntuple/obj/TStnTriggerBlock.hh>
#include <Stntuple/obj/TStnMuonBlock.hh>
#include <Stntuple/obj/TStnVertexBlock.hh>
#include <Stntuple/obj/TStnJetBlock.hh>
#include <Stntuple/obj/TStnMetBlock.hh>

#endif

class TSimpleExtrapolator;

class TMuoAnaModule: public TStnModule {
public:

  struct MuMuHist_t {
    TH1F*    fMass;
    TH1F*    fCharge;
    TH1F*    fPt;
  };

  struct MuoIDHist_t {
    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*    fFailedBits;
    TH1F*    fPassed;		// summary histogram
  };

  struct MuoHist_t {
    TH1F*    fDetector;
    TH1F*    fPt;
    TH2F*    fPtVsEta;
    TH2F*    fDetectorVsEta;
    TH2F*    fWedgeVsCmuDelXPos;
    TH2F*    fWedgeVsCmuDelXNeg;
    TH2F*    fWedgeVsCmuDelZ;
    TH1F*    fPhi;
    TH1F*    fEIso;
    TH1F*    fTIso;
    TH1F*    fCmuDelX;
    TH1F*    fCmuDelZ;
    TH1F*    fCmpDelX;
    TH1F*    fCmxDelX;
//-----------------------------------------------------------------------------
// Muon track histograms
//-----------------------------------------------------------------------------
    TH1F*    fTrackPt;
    TH1F*    fTrackD0;
    TH1F*    fTrackD0Corr;
    TH1F*    fTrackZ0;
    TH1F*    fTrackChi2;
    TH1F*    fTrackNCotHitsTot;
    TH1F*    fTrackNCotHitsAx;
    TH1F*    fTrackNCotHitsSt;
    TH1F*    fTrackCotChi2;
    TH1F*    fTrackAlgorithm;

    TH1F*    fExtDx;
    TH1F*    fExtDz;

    TH1F*    fHadEnergy;
    TH1F*    fEmEnergy;
  };

  struct EventHist_t {
    TH1F*    fNMuons;		// number of muon candidates per event
    TH1F*    fNGoodMuons;	// number of good muons
    TH1F*    fNLooseMuons;	// number of loose muons
    TH1F*    fNCmuStubs;
    TH1F*    fNCmpStubs;
    TH1F*    fNCmxStubs;
    TH1F*    fMet0      [2];
    TH1F*    fMet1      [2];
    TH1F*    fMt        [2];
    TH2F*    fIsoVsMet;
    TH2F*    fIso1VsMet;
    TH1F*    fMetPerp[2];
  };

  enum { kNMuonHistSets = 6 } ;

  struct Hist_t {

    MuoHist_t   fMuo[kNMuonHistSets];

    MuoIDHist_t fMuoID[4];
    MuMuHist_t  fMuMu[5];
    EventHist_t fEvent;
//-----------------------------------------------------------------------------
//  these 2 histograms should be must for any module
//-----------------------------------------------------------------------------
    TH1F*    fRunNumber;
    TH1F*    fFilterResult;
  };

protected:
					// pointers to the data blocks used
  TStnMuonBlock*     fMuonBlock;
  TStnTauBlock*      fTauBlock;
  TStnTriggerBlock*  fTriggerBlock;
  TStnTrackBlock*    fTrackBlock;
  TStnMetBlock*      fMetBlock;
  TStnJetBlock*      fJetBlock;
					// histograms filled
  Hist_t             fHist;
//-----------------------------------------------------------------------------
//  to do QCD fakes
//-----------------------------------------------------------------------------
  TObjArray*        fListOfGoodMuons;
  TObjArray*        fListOfLooseMuons;
  TObjArray*        fListOfNonTrigJets;
  TObjArray*        fListOfTriggerJets;
//-----------------------------------------------------------------------------
//  tau matching
//-----------------------------------------------------------------------------
  TStnTau*          fMatchingTau[100];
  Double_t          fDrTauMatch [100];
//-----------------------------------------------------------------------------
//  fudge factors
//-----------------------------------------------------------------------------
  Int_t             fDoFudging;
  Double_t          fFudgeScaleFactor[2];
  Double_t          fFudgeSigma      [2];
//-----------------------------------------------------------------------------
//  modes of operations
//-----------------------------------------------------------------------------
  Int_t       fDoQCDFakes;
  Int_t       fCutMode;		// 0: me, 1: etf, 2: etf_fid
//-----------------------------------------------------------------------------
//  id bits
//-----------------------------------------------------------------------------
  Int_t       fDetectorBit;
  Int_t       fPtBit;
  Int_t       fEEmBit;
  Int_t       fEHadBit;
  Int_t       fCmuDelXBit;
  Int_t       fCmuDelZBit;
  Int_t       fCmpDelXBit;
  Int_t       fCmxDelXBit;
  Int_t       fTrackZ0Bit;
  Int_t       fTrackD0Bit;
  Int_t       fEIsoBit;
  Int_t       fIso1Bit;
  Int_t       fTIsoBit;
  Int_t       fCotNAxBit;
  Int_t       fCotNStBit;
  Int_t       fSeedIEtaBit;
  Int_t       fWedgeNumberBit;
//-----------------------------------------------------------------------------
//  cuts defining ID bits
//-----------------------------------------------------------------------------
  Int_t       fDetectorMask;
  Double_t    fMinGoodMuonPt;		// minimal Pt of good muon
  Float_t     fMaxEEm;
  Float_t     fMaxEHad;
  Float_t     fMaxCmuDelX;
  Float_t     fMaxCmuDelZ;
  Float_t     fMaxCmpDelX;
  Float_t     fMaxCmxDelX;
  Float_t     fMaxEIso;
  Float_t     fMaxTIso;
  Float_t     fMaxCalIso1;
  Float_t     fMaxZ0;
  Float_t     fMaxD0;
  Int_t       fMinNCotAxHits;
  Int_t       fMinNCotStHits;
					// variables to filter on
  Int_t       fMinNGoodMuons;
  Double_t    fMinDrMetJet;

  Int_t       fMuoIDWord[100];
//-----------------------------------------------------------------------------
//  extrapolator
//-----------------------------------------------------------------------------
  TSimpleExtrapolator*   fExtrapolator;
//-----------------------------------------------------------------------------
// cached parameters:
//-----------------------------------------------------------------------------
  Int_t             fNRecoMuons;
  Int_t             fNGoodMuons;
  Int_t             fNLooseMuons;
  Int_t             fIMuo;
  Float_t           fMuonPt;
//-----------------------------------------------------------------------------
//  extrapolator
//-----------------------------------------------------------------------------
public:
  TMuoAnaModule(const char* name="MuoAna", const char* title="MuoAna");
  ~TMuoAnaModule();
					// ****** accessors

  Hist_t*                GetHist      () { return &fHist;         }
  MuoHist_t*             GetMuoHist  (Int_t I) { return &fHist.fMuo[I]; }

  TStnMuonBlock*      GetMuonBlock    () { return fMuonBlock; }
  TStnTriggerBlock*   GetTriggerBlock () { return fTriggerBlock;  }
  TStnTrackBlock*     GetTrackBlock   () { return fTrackBlock;    }

  Int_t               MinNGoodMuons   () { return fMinNGoodMuons; }

					// ****** modifiers

  void    SetMinNGoodMuons    (Int_t      N) { fMinNGoodMuons     = N;  }
  void    SetMinGoodMuonPt    (Double_t  Pt) { fMinGoodMuonPt     = Pt; }
  void    SetMaxTIso          (Float_t  Iso) { fMaxTIso           = Iso;}
  void    SetMaxCalIso1       (Float_t  Iso) { fMaxCalIso1        = Iso;}

  void    SetCutMode          (Int_t      M) { fCutMode           = M;  }
  void    SetDoFudging        (Int_t     Do) { fDoFudging         = Do;}

  void    SetFudgeScaleFactor (Int_t I, Double_t  F ) { 
    fFudgeScaleFactor[I]  = F; 
  }

  void    SetFudgeSigma       (Int_t I, Double_t  F ) { 
    fFudgeSigma[I]        = F; 
  }
					// ****** overloaded methods of 
					// TStnModule
  int     BeginJob();
  int     BeginRun();
  int     Event   (int ientry);
  int     EndJob  ();
					// ****** other methods

//-----------------------------------------------------------------------------
// define muon bit-packed ID word
//-----------------------------------------------------------------------------
  int     MuoIDWord      (const TStnMuon* Muo);

  void    BookEventHistograms (EventHist_t& Hist, Int_t I);
  void    BookMuonIDHistograms(MuoIDHist_t& Hist, const char* Folder);
  void    BookMuonHistograms  (MuoHist_t&   Hist, const char* Folder);
  void    BookMuMuHistograms  (MuMuHist_t&  Hist, Int_t I);
  void    BookHistograms();


  void    FillEventHistograms (EventHist_t& Hist);
  void    FillMuonHistograms  (MuoHist_t&   Hist, TStnMuon* Ele);
  void    FillMuonIDHistograms(MuoIDHist_t& Hist, TStnMuon* Ele);

  void    PlotHistograms(int run_number, int slide);

  ClassDef(TMuoAnaModule,0)
};