#ifndef TMBMet_H
#define TMBMet_H

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMBTree Met class                                                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TObject
#include "TObject.h"
#endif

class TMBMet : public TObject {

private:
  // no ET or Eta Limits
   Float_t          _MET;            //Met
   Float_t          _MEx;            //Mex
   Float_t          _MEy;            //Mey
   Float_t          _ScalarET;      //Scalar_et

  // with ET limit only
  Float_t _MET_noeta;
  Float_t _MEx_noeta;
  Float_t _MEy_noeta;
  Float_t _ScalarET_noeta;

  // with ET and Eta limits
  Float_t _MET_weta;
  Float_t _MEx_weta;
  Float_t _MEy_weta;
  Float_t _ScalarET_weta;

  // Ring variables: 74 ieta rings {-34:34}
  Int_t _nrings;  
  Float_t *_RingEMx; //[_nrings]
  Float_t *_RingEMy; //[_nrings]
  Float_t *_RingHDx; //[_nrings]
  Float_t *_RingHDy; //[_nrings]

  Float_t _visMuX, _visMuY, _visMuPt;

  // Z of the vertex used to calculate mET
  Float_t _Zvertex;       

    // MET for CAL + ICD Towers
    Float_t _SETT;
    Float_t _METTx;
    Float_t _METTy;
    Float_t _METT;
// MET for CAL + ICD Towers + Muon correction
    Float_t _SETTM;
    Float_t _METTMx;
    Float_t _METTMy;
    Float_t _METTM;
    //
       // Vis. Et for CAL + ICD Towers above eta limit, above tower threshold
    Float_t _SETTAS;
    Float_t _VETTASx;
    Float_t _VETTASy;
    Float_t _VETTAS;

   // Vis. Et for CAL + ICD Towers below eta limit, above tower threshold
    Float_t _SETTBS;
    Float_t _VETTBSx;
    Float_t _VETTBSy;
    Float_t _VETTBS;

   // Vis. Et for CAL + ICD Towers above eta limit, below tower threshold
    Float_t _SETTAN;
    Float_t _VETTANx;
    Float_t _VETTANy;
    Float_t _VETTAN;

   // Vis. Et for CAL + ICD Towers below eta limit, below tower threshold
  Float_t _SETTBN;
  Float_t _VETTBNx;
  Float_t _VETTBNy;
  Float_t _VETTBN;

  // MET for CAL + ICD Cells
  Float_t _SETC;
  Float_t _METCx;
  Float_t _METCy;
  Float_t _METC;

  // MET for CAL + ICD Cells + Muon correction
  Float_t _SETCM;
  Float_t _METCMx;
  Float_t _METCMy;
  Float_t _METCM;

  // Vis. Et for CAL + ICD Cells above eta limit, above cell threshold
  Float_t _SETCAS;
  Float_t _VETCASx;
  Float_t _VETCASy;
  Float_t _VETCAS;

  // Vis. Et for CAL + ICD Cells below eta limit, above cell threshold
  Float_t _SETCBS;
  Float_t _VETCBSx;
  Float_t _VETCBSy;
  Float_t _VETCBS;

  // Vis. Et for CAL + ICD Cells above eta limit, below cell threshold
  Float_t _SETCAN;
  Float_t _VETCANx;
  Float_t _VETCANy;
  Float_t _VETCAN;

  // Vis. Et for CAL + ICD Cells below eta limit, below cell threshold
  Float_t _SETCBN;
  Float_t _VETCBNx;
  Float_t _VETCBNy;
  Float_t _VETCBN;

  // Vis. Et for ICD Cells
  Float_t _SETICD;
  Float_t _VETICDx;
  Float_t _VETICDy;
  Float_t _VETICD;

  // Vis. Et for NADA Cells
  Float_t _SETNADA;
  Float_t _VETNADAx;
  Float_t _VETNADAy;
  Float_t _VETNADA;

  // Tight Muons
  Float_t _VETMUONx;
  Float_t _VETMUONy;
  Float_t _VETMUONz;
  Float_t _VETMUON;
  ///////////////////////////////////////////////////
  // p15 new variable set  (2/20/2003)             //
  // MET for CAL + ICD Cells
  Float_t _VETCx; // _METCx and _METCy already declared
  Float_t _VETCy;

  // MET for CAL + ICD Cells + Muon correction
  Float_t _VETCMx; // _METCMx and METCMy already declared
  Float_t _VETCMy;

  // MET for CAL + ICD Cells layers 1-14 (no CH)
  Float_t _SETD;
  Float_t _VETDx;
  Float_t _VETDy;
  Float_t _METD;

  // MET for CAL + ICD Cells layers 1-14 (no CH) + Muon correction
  Float_t _SETDM;
  Float_t _VETDMx;
  Float_t _VETDMy;
  Float_t _METDM;

  // MET for EM layers (1-7)
  Float_t _SETEM;
  Float_t _VETEMx;
  Float_t _VETEMy;
  Float_t _METEM;

  // MET for Massless Gap layers (8&10)
  Float_t _SETMG;
  Float_t _VETMGx;
  Float_t _VETMGy;
  Float_t _METMG;

  // MET for FH layers (11-14)
  Float_t _SETFH;
  Float_t _VETFHx;
  Float_t _VETFHy;
  Float_t _METFH;

  // MET for CH layers (15-17)
  Float_t _SETCH;
  Float_t _VETCHx;
  Float_t _VETCHy;
  Float_t _METCH;

  // MET for CAL + ICD Cells below eta limit.(no threshold)
  Float_t _EDge;
  Float_t _SETED;
  Float_t _VETEDx;
  Float_t _VETEDy;
  Float_t _METED;

  // MET for negative cells
  Float_t _SETNG;
  Float_t _VETNGx;
  Float_t _VETNGy;
  Float_t _METNG;

  // MET for noise cells, based onthe CalT42 algorithm.
  Float_t _SET42;
  Float_t _VET42x;
  Float_t _VET42y;
  Float_t _MET42;

  // Define just MET qunatities for ICD, NADA, and MUON
  Float_t _METICD;
  Float_t _METNADA;
  Float_t _METMUON;

  Float_t _DMETACHx;
  Float_t _DMETACHy;
  Float_t _SETACH;

  Float_t _DMETBCHx;
  Float_t _DMETBCHy;
  Float_t _SETBCH;

  // Electrons : 
  // a) match electrons with jets
  // b) remove electrons from jet list
  // c) correct electron energies with EM energy scale.
  // d) compute MET correction
  // Remarks : what happens if we have an electron of 10 GeV in a jet of 50 GeV ?
  // Electron R=0.4, and jets R=0.5 or 0.7 : it should not happen often
  Float_t _DMETAELx;
  Float_t _DMETAELy;
  Float_t _SETAEL;

  Float_t _DMETBELx;
  Float_t _DMETBELy;
  Float_t _SETBEL;

  // Jet Energy Scale : 
  // a) Match muons with jets
  // b) add the muon to the jet in jetcorr object : jetcorr::addMuon() 
  // c) compute JES correction and get MET correction : jetcorr::forMET()
  // Warning : we check with Andrey that the MET correction in jetcorr
  // do not take into account the muon. MET for Matched muons must be 
  // corrected as for non-matched muons (to be checked with JES group)
  Float_t _DMETAJESx;
  Float_t _DMETAJESy;
  Float_t _SETAJES;

  Float_t _DMETBJESx;
  Float_t _DMETBJESy;
  Float_t _SETBJES;

  // Muons :
  // Correct missing ET from muons :
  // a) add muon 4-vectors
  // b) treat also muon energy deposit in the calorimeter
  Float_t _DMETAMUx;
  Float_t _DMETAMUy;
  Float_t _SETAMU;

  Float_t _DMETBMUx;
  Float_t _DMETBMUy;
  Float_t _SETBMU;

  // Unclustered energy :
  // We will perform a calibration of the unclustered energy.
  // The correction should be an analytic function, but it could be more
  // complicated than that. So let's reserve variables for that correction
  Float_t _DMETAUEx;
  Float_t _DMETAUEy;
  Float_t _SETAUE;

  Float_t _DMETBUEx;
  Float_t _DMETBUEy;
  Float_t _SETBUE;
  // bad jets :
  // What are we doing with bad jets ? (bad jets = the ones which do not pass 
  // good jet criteria and the ones for which we cannot apply the JES correction  
  // because there are eta and Pt cuts.
  Float_t _DMETABJx;
  Float_t _DMETABJy;
  Float_t _SETABJ;

  Float_t _DMETBBJx;
  Float_t _DMETBBJy;
  Float_t _SETBBJ;

   

public:
TMBMet();

TMBMet(Float_t MET, Float_t MEx, Float_t MEy, Float_t ScalarET,
      Float_t MET_noeta, Float_t MEx_noeta, Float_t MEy_noeta, Float_t ScalarET_noeta,
      Float_t MET_weta, Float_t MEx_weta, Float_t MEy_weta, Float_t ScalarET_weta,
      Int_t nrings, const Float_t *RingEMx, const Float_t *RingEMy, 
      const Float_t *RingHDx, const Float_t *RingHDy, Float_t Zvertex); 
     
TMBMet ( const TMBMet & met ); // copy constructor

void Set(Float_t MET, Float_t MEx, Float_t MEy, Float_t ScalarET,
       Float_t MET_noeta, Float_t MEx_noeta, Float_t MEy_noeta, Float_t ScalarET_noeta,
       Float_t MET_weta, Float_t MEx_weta, Float_t MEy_weta, Float_t ScalarET_weta,
       Int_t nrings, const Float_t *RingEMx, const Float_t *RingEMy, 
       const Float_t *RingHDx, const Float_t *RingHDy, Float_t Zvertex);

void Set1(Float_t visMuX, Float_t visMuY, Float_t visMuPt, 
  Float_t SETT, Float_t METTx, Float_t METTy, Float_t METT,
  Float_t SETTM, Float_t METTMx, Float_t METTMy, Float_t METTM,
  Float_t SETTAS, Float_t VETTASx, Float_t VETTASy, Float_t VETTAS, 
  Float_t SETTBS, Float_t VETTBSx, Float_t VETTBSy, Float_t VETTBS,
  Float_t SETTAN, Float_t VETTANx, Float_t VETTANy, Float_t VETTAN,
  Float_t SETTBN, Float_t VETTBNx, Float_t VETTBNy, Float_t VETTBN,
  Float_t SETC, Float_t METCx, Float_t METCy, Float_t METC,
  Float_t SETCM, Float_t METCMx, Float_t METCMy, Float_t METCM);

void Set2(Float_t SETCAS, Float_t VETCASx, Float_t VETCASy, Float_t VETCAS,
  Float_t SETCBS, Float_t VETCBSx, Float_t VETCBSy, Float_t VETCBS,
  Float_t SETCAN, Float_t VETCANx, Float_t VETCANy, Float_t VETCAN,
  Float_t SETCBN, Float_t VETCBNx, Float_t VETCBNy, Float_t VETCBN,
  Float_t SETICD, Float_t VETICDx, Float_t VETICDy, Float_t VETICD,
  Float_t SETNADA, Float_t VETNADAx, Float_t VETNADAy, Float_t VETNADA,
  Float_t VETMUONx, Float_t VETMUONy, Float_t VETMUONz, Float_t VETMUON,
  Float_t VETCx, Float_t VETCy, Float_t VETCMx,Float_t VETCMy,
  Float_t SETD, Float_t VETDx, Float_t VETDy, Float_t METD);

void Set3( Float_t SETDM, Float_t VETDMx, Float_t VETDMy, Float_t METDM,
  Float_t SETEM, Float_t VETEMx, Float_t VETEMy, Float_t METEM,
  Float_t SETMG, Float_t VETMGx, Float_t VETMGy, Float_t METMG,
  Float_t ETFH, Float_t VETFHx, Float_t VETFHy, Float_t METFH,
  Float_t SETCH, Float_t VETCHx, Float_t VETCHy, Float_t METCH,
  Float_t EDge, Float_t SETED, Float_t VETEDx, Float_t VETEDy, Float_t METED,
  Float_t SETNG, Float_t VETNGx, Float_t VETNGy, Float_t METNG,
  Float_t SET42, Float_t VET42x, Float_t VET42y, Float_t MET42,
  Float_t METICD, Float_t METNADA, Float_t METMUON);


void Set4(  Float_t DMETACHx, Float_t DMETACHy, Float_t SETACH,
  Float_t DMETBCHx, Float_t DMETBCHy, Float_t SETBCH,
  Float_t DMETAELx, Float_t DMETAELy, Float_t SETAEL,
  Float_t DMETBELx, Float_t DMETBELy, Float_t SETBEL, 
  Float_t DMETAJESx, Float_t DMETAJESy, Float_t SETAJES,
  Float_t DMETBJESx, Float_t DMETBJESy, Float_t SETBJES,
  Float_t DMETAMUx, Float_t DMETAMUy, Float_t SETAMU,
  Float_t DMETBMUx, Float_t DMETBMUy, Float_t SETBMU,
  Float_t DMETAUEx, Float_t DMETAUEy, Float_t SETAUE,
  Float_t DMETBUEx, Float_t DMETBUEy, Float_t SETBUE,
  Float_t DMETABJx, Float_t DMETABJy, Float_t SETABJ,
  Float_t DMETBBJx, Float_t DMETBBJy, Float_t SETBBJ);





  virtual       ~TMBMet();

  // return missing ET
  Float_t getMET() const;
  Float_t getMET_noeta() const;
  Float_t getMET_weta() const;

  // return scalar ET
  Float_t getScalarET() const;
  Float_t getScalarET_noeta() const;
  Float_t getScalarET_weta() const;

  // return missing ETx, ETy
  void getMExy(Float_t &ETx, Float_t &ETy) const;
  void getMExy_noeta(Float_t &ETx_noeta, Float_t &ETy_noeta) const;
  void getMExy_weta(Float_t &ETx_weta, Float_t &ETy_weta) const;

  // return Ring ETx, ETy
  Int_t numRings() const;
  void getRings(const Float_t *&RingEMx, const Float_t *&RingEMy,
		const Float_t *&RingHDx, const Float_t *&RingHDy) const;

  // return vertex used to calculate MET
  void getZvertex(Float_t &Zvertex) const;
  
  void getVisMu(Float_t &visMuX, Float_t &visMuY, Float_t &visMuPt) const;

// Variables added 4/27/2002 in missingET

  void getMETT(Float_t &SETT, Float_t &METTx, Float_t &METTy, Float_t &METT) const;
  void getMETTM(Float_t &SETTM, Float_t &METTMx, Float_t &METTMy, Float_t &METTM) const;
  void getVETTAS(Float_t &SETTAS, Float_t &VETTASx, Float_t &VETTASy, Float_t &VETTAS) const;
  void getVETTBS(Float_t &SETTBS, Float_t &VETTBSx, Float_t &VETTBSy, Float_t &VETTBS) const;
  void getVETTAN(Float_t &SETTAN, Float_t &VETTANx, Float_t &VETTANy, Float_t &VETTAN) const;
  void getVETTBN(Float_t &SETTBN, Float_t &VETTBNx, Float_t &VETTBNy, Float_t &VETTBN) const;
  void getMETC(Float_t &SETC, Float_t &METCx, Float_t &METCy, Float_t &METC) const;
  void getMETCM(Float_t &SETCM, Float_t &METCMx, Float_t &METCMy, Float_t &METCM) const;
  void getVETCAS(Float_t &SETCAS, Float_t &VETCASx, Float_t &VETCASy, Float_t &VETCAS) const;
  void getVETCBS(Float_t &SETCBS, Float_t &VETCBSx, Float_t &VETCBSy, Float_t &VETCBS) const;
  void getVETCAN(Float_t &SETCAN, Float_t &VETCANx, Float_t &VETCANy, Float_t &VETCAN) const;
  void getVETCBN(Float_t &SETCBN, Float_t &VETCBNx, Float_t &VETCBNy, Float_t &VETCBN) const;
  void getVETICD(Float_t &SETICD, Float_t &VETICDx, Float_t &VETICDy, Float_t &VETICD) const;
  void getVETNADA(Float_t &SETNADA, Float_t &VETNADAx, Float_t &VETNADAy, Float_t &VETNADA) const;
  void getVETMUON(Float_t &VETMUONx, Float_t &VETMUONy, Float_t &VETMUONz, Float_t &VETMUON) const;

// New variables added 2/20/2003 in missingET

  void getVETC(Float_t &SETC, Float_t &VETCx, Float_t &VETCy, Float_t &METC) const;
  void getVETCM(Float_t &SETCM, Float_t &VETCMx, Float_t &VETCMy, Float_t &METCM) const;

  void getVETD(Float_t &SETD, Float_t &VETDx, Float_t &VETDy, Float_t &METD) const;
  void getVETDM(Float_t &SETDM, Float_t &VETDMx, Float_t &VETDMy, Float_t &METDM) const;
  // Additional accessors for missing (and not visible) ET w/out CH
  void getMETD(Float_t &SETD, Float_t &METDx, Float_t &METDy, Float_t &METD) const;
  void getMETDM(Float_t &SETDM, Float_t &METDMx, Float_t &METDMy, Float_t &METDM) const;

  void getVETEM(Float_t &SETEM, Float_t &VETEMx, Float_t &VETEMy, Float_t &METEM) const;
  void getVETMG(Float_t &SETMG, Float_t &VETMGx, Float_t &VETMGy, Float_t &METMG) const;
  void getVETFH(Float_t &SETFH, Float_t &VETFHx, Float_t &VETFHy, Float_t &METFH) const;
  void getVETCH(Float_t &SETCH, Float_t &VETCHx, Float_t &VETCHy, Float_t &METCH) const;

  void getVETED(Float_t &EDGE, Float_t &SETED, Float_t &VETEDx, Float_t &VETEDy, Float_t &METED) const;

  void getVETNG(Float_t &SETNG, Float_t &VETNGx, Float_t &VETNGy, Float_t &METNG) const;
  void getVET42(Float_t &SET42, Float_t &VET42x, Float_t &VET42y, Float_t &MET42) const;

// New variables added 08-Oct-2003 (Patrice Verdier)

  // CH corrections :
  void  getDMETACHxy(Float_t &DMETACHx,Float_t &DMETACHy) const;
  void  getDMETBCHxy(Float_t &DMETBCHx,Float_t &DMETBCHy) const;
  Float_t getDMETACH() const;
  Float_t getDMETBCH() const;
  Float_t getSETACH() const;
  Float_t getSETBCH() const;

  // Electron corrections :
  void  getDMETAELxy(Float_t &DMETAELx,Float_t &DMETAELy) const;
  void  getDMETBELxy(Float_t &DMETBELx,Float_t &DMETBELy) const;
  Float_t getDMETAEL() const;
  Float_t getDMETBEL() const;
  Float_t getSETAEL() const;
  Float_t getSETBEL() const;

  // JES corrections :
  void getDMETAJESxy(Float_t &DMETAJESx,Float_t &DMETAJESy) const;
  void getDMETBJESxy(Float_t &DMETBJESx,Float_t &DMETBJESy) const;
  Float_t getDMETAJES() const;
  Float_t getDMETBJES() const;
  Float_t getSETAJES() const;
  Float_t getSETBJES() const;

  // Muon corrections :
  void getDMETAMUxy(Float_t &DMETAMUx,Float_t &DMETAMUy) const;
  void getDMETBMUxy(Float_t &DMETBMUx,Float_t &DMETBMUy) const;
  Float_t getDMETAMU() const;
  Float_t getDMETBMU() const;
  Float_t getSETAMU() const;
  Float_t getSETBMU() const;

  // Unclustered energy corrections :
  void getDMETAUExy(Float_t &DMETAUEx,Float_t &DMETAUEy) const;
  void getDMETBUExy(Float_t &DMETBUEx,Float_t &DMETBUEy) const;
  Float_t getDMETAUE() const;
  Float_t getDMETBUE() const;
  Float_t getSETAUE() const;
  Float_t getSETBUE() const;
  // Bad jets corrections :
  void getDMETABJxy(Float_t &DMETABJx,Float_t &DMETABJy) const;
  void getDMETBBJxy(Float_t &DMETBBJx,Float_t &DMETBBJy) const;
  Float_t getDMETABJ() const;
  Float_t getDMETBBJ() const;
  Float_t getSETABJ() const;
  Float_t getSETBBJ() const;

  // New accessor functions :
  Float_t getMETA() const;
  Float_t getMETB() const;
  void  getMETAxy(Float_t &METx,Float_t &METy) const;
  void  getMETBxy(Float_t &METx,Float_t &METy) const;
  Float_t getSETA() const;
  Float_t getSETB() const;

  Float_t getMETACorrCALO() const;
  Float_t getMETBCorrCALO() const;
  void  getMETACorrCALOxy(Float_t &METx,Float_t &METy) const;
  void  getMETBCorrCALOxy(Float_t &METx,Float_t &METy) const;
  Float_t getSETACorrCALO() const;
  Float_t getSETBCorrCALO() const;

  Float_t getMETACorrCALOMU() const;
  Float_t getMETBCorrCALOMU() const;
  void  getMETACorrCALOMUxy(Float_t &METx,Float_t &METy) const;
  void  getMETBCorrCALOMUxy(Float_t &METx,Float_t &METy) const;
  Float_t getSETACorrCALOMU() const;
  Float_t getSETBCorrCALOMU() const;



   ClassDef(TMBMet, 2)   //TMBTree Met class
};

#endif