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

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

#include <Stntuple/loop/TStnModule.hh>

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

#endif

class TStnElectronID;
class TSimpleExtrapolator;

class TWenuMonModule: public TStnModule {
public:
  struct EEHist_t {
    TH1F*    fMass;
    TH1F*    fCharge;
    TH1F*    fPt;
  };

  struct EleIDHist_t {
    TH1F*    fCentral     [5];
    TH1F*    fDetEta      [5];
    TH1F*    fIso         [5];
    TH1F*    fIso1        [5];
    TH1F*    fHadEm       [5];
    TH1F*    fEOverP      [5];
    TH1F*    fEt          [5];
    TH1F*    fSeedIEta    [5];
    TH1F*    fWedgeNumber [5];
    TH1F*    fTrackPt     [5];
    TH1F*    fChi2Strip   [5];
    TH1F*    fXCes        [5];
    TH1F*    fZCes        [5];
    TH1F*    fDelX        [5];
    TH1F*    fDelZ        [5];
    TH1F*    fLshr        [5];
    TH1F*    fLshr2       [5];
    TH1F*    fTIso        [5];
    TH1F*    fTrackD0     [5];
    TH1F*    fTrackZ0     [5];
    TH1F*    fCotNAxHits  [5];
    TH1F*    fCotNStHits  [5];
    TH1F*    fFailedBits;
    TH1F*    fPassed;		// summary histogram
  };

  struct EleHist_t {
    TH1F*    fEt;
    TH2F*    fEtVsEta;
    TH2F*    fWedgeVsDelXPos;
    TH2F*    fWedgeVsDelXNeg;
    TH2F*    fWedgeVsZCes;
    TH2F*    fWedgeVsDelZ;
    TH2F*    fEmfrVsDelZ;
    TH1F*    fPhi;
    TH1F*    fN10;
    TH1F*    fIso;
    TH1F*    fIso1;
    TH1F*    fDelX;
    TH1F*    fDelZ;
    TH1F*    fEOverP;
    TH1F*    fEOverPPos;
    TH1F*    fEOverPNeg;
    TH1F*    fHadEm;
    TH1F*    fNCesStripClusters;
    TH1F*    fNCesWireClusters;
    TH1F*    fCesStripEnergy;
    TH1F*    fCesWireEnergy;
    TH2F*    fCesEStripVsEWire;
    TH2F*    fCesEStripVsEta[2];
    TH2F*    fCesEStripVsEt[2];
    TH1F*    fCesStripChi2;
    TH1F*    fCesWireChi2;
    TH1F*    fXCes;
    TH1F*    fZCes;
    TH1F*    fLshr;
    TH1F*    fLshr2;
    TH1F*    fMass;
//-----------------------------------------------------------------------------
// electron track histograms
//-----------------------------------------------------------------------------
    TH1F*    fTrackPt;
    TH1F*    fTrackD0;
    TH1F*    fTrackD0Corr;
    TH1F*    fTrackZ0;
    TH1F*    fTrackChi2;
    TH1F*    fTrackNCotHitsTot;
    TH1F*    fTrackNCotHitsAx;
    TH1F*    fTrackNCotHitsSt;
    TH1F*    fTrackCotChi2;
    TH1F*    fTIso;
    TH1F*    fTrackXCes;
    TH1F*    fTrackZCes;

    TH1F*    fNSvxHits;		// total number of SVX hits
    TH1F*    fNSvxRPhiHits;
    TH1F*    fNSvxSASHits;
    TH1F*    fNSvxZHits;

    TH1F*    fExtDx;
    TH1F*    fExtDz;

    TH1F*    fFailedBits;
  };

  struct EScaleHist_t {
    TH1F*    fEoverP_inc;
    TH1F*    fEoverP_NE;
    TH1F*    fEoverP_NW;
    TH1F*    fEoverP_SE;
    TH1F*    fEoverP_SW;
    TH1F*    fZMass_inc;
    TH1F*    fZMass_CC;
    TH1F*    fZMass_CP;
    TH1F*    fZMass_CPW;
    TH1F*    fZMass_CPE;
  };

  struct EventHist_t {
    TH1F*    fMet0;
    TH1F*    fMet1;
    TH2F*    fMet0VsMet1;
    TH1F*    fMt[2];
    TH1F*    fNTracks;
    TH1F*    fNGoodEle;
    TH1F*    fNLooseEle;
    TH2F*    fIsoVsMet;
    TH2F*    fIso1VsMet;
    TH1F*    fMetPerp[2];
  };

//-----------------------------------------------------------------------------
// set 0 : all   electrons
// set 1 : tight electrons
// set 2 : loose electrons
// set 3 : electrons with I/O tracks
//-----------------------------------------------------------------------------
  enum { kNElectronHistSets = 4 };

  struct Hist_t {
    EleHist_t    fEle[kNElectronHistSets]   ;
    EEHist_t     fEEHist[2];
    EventHist_t  fEventHist;
    EScaleHist_t fEScaleHist;

    TH1F*       fRunNumber;
    TH1F*       fFilterResult;
  };

protected:
					// pointers to the data blocks used
  TStnElectronBlock* fElectronBlock;
  TStnTriggerBlock*  fTriggerBlock;
  TStnTrackBlock*    fTrackBlock;
  TStnMetBlock*      fMetBlock;
					// histograms filled
  Hist_t      fHist;
//-----------------------------------------------------------------------------
//  to study electron ID efficiencies
//-----------------------------------------------------------------------------
  Int_t             fIdWord     [100];
  Int_t             fLooseIdWord[100];
  TObjArray*        fListOfGoodElectrons;
  TObjArray*        fListOfLooseElectrons;
  Int_t             fNTightElectrons;
  Int_t             fNLooseElectrons;
  Int_t             fNEmObjects;
					// variables to filter on
  Int_t       fMinNTightElectrons;
  Int_t       fMaxNTightElectrons;
  Int_t       fMinNLooseElectrons;
  Int_t       fMaxNLooseElectrons;
  Int_t       fMinNEmObjects;
  Int_t       fMaxNEmObjects;


  TStnElectronID*   fTightID;
  TStnElectronID*   fLooseID;
//-----------------------------------------------------------------------------
//  modes of operations
//-----------------------------------------------------------------------------
  Int_t       fCutMode;		// 0: me, 1: etf, 2: etf_fid
//-----------------------------------------------------------------------------
//  extrapolator
//-----------------------------------------------------------------------------
  TSimpleExtrapolator*   fExtrapolator;

public:
  TWenuMonModule(const char* name="WenuMon", const char* title="WenuMon");
  ~TWenuMonModule();
//-----------------------------------------------------------------------------
// accessors
//-----------------------------------------------------------------------------
  Hist_t*             GetHist         () { return &fHist;         }
  EleHist_t*          GetEleHist(int i)  { return &fHist.fEle[i]; }
  TStnElectronBlock*  GetElectronBlock() { return fElectronBlock; }
  TStnTriggerBlock*   GetTriggerBlock () { return fTriggerBlock;  }
  TStnTrackBlock*     GetTrackBlock   () { return fTrackBlock;    }
  TStnElectronID*     GetTightID      () { return fTightID;       }
  TStnElectronID*     GetLooseID      () { return fLooseID;       }
//-----------------------------------------------------------------------------
// modifiers
//-----------------------------------------------------------------------------
  void    SetMaxNTightElectrons(Int_t      N) { fMaxNTightElectrons = N;  }
  void    SetMinNTightElectrons(Int_t      N) { fMinNTightElectrons = N;  }
  void    SetMaxNLooseElectrons(Int_t      N) { fMaxNLooseElectrons = N;  }
  void    SetMinNLooseElectrons(Int_t      N) { fMinNLooseElectrons = N;  }
  void    SetMaxNEmObjects     (Int_t      N) { fMaxNEmObjects      = N;  }
  void    SetMinNEmObjects     (Int_t      N) { fMinNEmObjects      = N;  }
  void    SetCutMode           (Int_t      M) { fCutMode            = M;  }
//-----------------------------------------------------------------------------
// overloaded methods of TStnModule
//-----------------------------------------------------------------------------
  int     BeginJob();
  int     BeginRun();
  int     Event   (int ientry);
  int     EndJob  ();
//-----------------------------------------------------------------------------
// other methods
//-----------------------------------------------------------------------------
  int     Debug();
  void    BookEEHistograms        (EEHist_t&    Hist, Int_t I);
  void    BookElectronHistograms  (EleHist_t&   Hist, const char* Folder);
  void    BookEScaleHistograms    (EScaleHist_t& Hist);
  void    BookEventHistograms     (EventHist_t& Hist, Int_t I);
  void    BookHistograms();


  void    FillElectronHistograms  (EleHist_t&    Hist, TStnElectron* Ele);

  void    FillEEHistograms        (EEHist_t&     Hist, 
				   TStnElectron* E1  ,
				   TStnElectron* E2  );

  void    FillEScaleHistograms     (EScaleHist_t& Hist, TStnElectron* Ele);
  void    FillEScaleHistograms     (EScaleHist_t& Hist, TStnElectron* Ele1, TStnElectron* Ele2);

  void    FillEventHistograms     (EventHist_t& Hist);

  void    PlotHistograms(int run_number, int slide);

  ClassDef(TWenuMonModule,0)
};