#ifndef TMBMuon_H
#define TMBMuon_H

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMBTree Muon class                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "tmb_tree/TPhysObj.hpp"
#ifndef ROOT_TRef
#include "TRef.h"
#endif
#ifndef ROOT_TRefArray
#include "TRefArray.h"
#endif
#include "TArrayI.h"
#include "TString.h"


class TMBTrks;
class TMBVrts;


class TMBMuon : public TPhysObj {

private:

  Float_t      _px;  	// px of the muon
  Float_t      _py;  	// py of the muon
  Float_t      _pz;  	// pz of the muon
  Float_t      _E;   	// Energy of the muon
  Float_t      _pT;  	// pT of the muon 
  Float_t      _eta;   	// eta of the muon
  Float_t      _phi;   	// phi of the muon
  Float_t      _charge; // charge of the muon
  Float_t      _tanl;  	// tan Lambda
  Int_t        _nhit;  	// Matching hits,  defined as (nwhitA+10*nwhitBC+1000*nshitA+10000*nshitBC)
  Int_t        _nseg;   // Matching segments (0: no segments;) (1:A layer; 2:BC; 3:A+BC; -3:A+BC w/o GTrack)
  Int_t        _nmtc;  	// MTC track: -1 not done, 0 not found, 1 found
  Float_t      _deltaPhi;    // delta_phi between A layer segment and the matching charged particle 
  Float_t      _deltaEta;    // delta_eta between A layer segment and the matching charged particle 
  Float_t      _deltaDrift;  // distance between A layer segment and the matching charged particle 
  Float_t      _chisq;       // Chisqure from global matching 
  Float_t      _hfrac_hit;   // Fraction of hadronic cal cells hit by the muon 
  Float_t      _etrack_hit;  // Energy in cal cells hit by the muon 
  Float_t      _hfrac_best;  // Fraction of hadr. cal layers with energy, from the matching MTC track (not yet implemented) 
  Float_t      _etrack_best; // Energy in cal cells associated with the matching MTC track
  Float_t      _elast;       // Energy in last hadronic layer 
  Float_t      _e33;  	     // Energy in a 3 by 3 tower around the muon 
  Float_t      _e55;  	     // Energy in a 5 by 5 tower around the muon 
  TRef         _chptr;       // Link to the corresponding charged particle object
  TRef         _vtxref;      // Link to the corresponding vertex object
  Int_t        _ndeck;      // Matching decks, defined as (nwdeckA+10*nwdeckBC+1000*nsdeckA+10000*nsdeckBC)
  Int_t        _categoryloc;  	// (-2:BC seg only,-1:A-stub,0:A+BC (no fit),1: A+BC + converged fit)
  Int_t        _qualityloc;   	// Local muon quality definition 
  Int_t        _statusloc;   	// Status of local muon fitting 
  Int_t        _centralmatch;  	// Number of Central-matched Muon for one track 
  Int_t        _centralrank; 	// Rank of track matching in case of ambiguity 
  Float_t      _chisqloc;   	// Chisqure from local muon fitting
  Float_t      _qptloc;   	// Local Muon qpt(=charge*pt)
  Float_t      _sctimeA;   	// Scintillator time for A-segment 
  Float_t      _sctimeBC;   	// Scintillator time for (B and/or C) segment 
  Float_t      _scvelo;         // Velocity from Sintillator times (not implemented) 
  Float_t      _xA;   		// x coordinate of center point of A-segment 
  Float_t      _yA;   		// y coordinate of center point of A-segment 
  Float_t      _zA;   		// z coordinate of center point of A-segment 
  Float_t      _pxA;   		// px from fit at A-layer, uncorrected for eloss_cal 
  Float_t      _pyA;   		// py from fit at A-layer, uncorrected for eloss_cal 
  Float_t      _pzA;  		// pz from fit at A-layer, uncorrected for eloss_cal 
  Float_t      _phiA;  		// phi of direction of A-segment 
  Float_t      _etaA;  		// eta of direction of A-segment 
  Int_t	       _segIndex;  // Index of segment used to defined the MuonParticle with nseg=1 or 2 (=-1 for nseg!=1,2)
  Int_t        _TrkIndex;

  bool 	       _isTightMuoTrack;
  Float_t      _zAtPca;         // z coordinate at Pca (cm)
  Float_t      _impPar;   	// Impact parameter in xy plane (cm) 
  Float_t      _impParSig; 	// Muonid impact parameter significance
  Float_t      _err_impPar;  	// Error of impact parameter 
  Float_t      _err_zAtPca;  	// Error of z coordinate at Pca 
  Float_t      _err_phi;   	// Error of Phi 
  Float_t      _err_tanLam;  	// Error of tanLam
  Float_t      _err_pT;  	// Error of pT

  // isolation variables
  Float_t      _EInCone1;
  Float_t      _EInCone15;
  Float_t      _EInCone2;
  Float_t      _EInCone4;
  Float_t      _EInCone6;

  // MTC variables
  Int_t        _calnLayer;
  Float_t      _caleSig;
  Float_t      _calEta;
  Float_t      _calPhi;

  Int_t        _region;
  Int_t        _octant;
  
  // variables specific to MuoCandidate:
  Float_t _pTCorr;
  Int_t _chargeCorr;
  Float_t _pTCentral;
  Float_t _eloss;
  Int_t _expWhitsA;
  Int_t _expWhitsBC;
  Int_t _expShitsA;
  Int_t _expShitsBC;
  Int_t _isLoose;
  Int_t _isMedium;
  Int_t _isTight;
  Int_t _hasLocal;
  Int_t _hasCentral;
  Int_t _hasCal;
  Int_t _isAxialMatched;
  Float_t _drJet5;
  Int_t _nTrk5;
  Float_t _etTrkCone5;
  Float_t _etHalo;
  Float_t _bdl;
  Int_t _isMuonEventOK;
  Float_t _roadEM;
  Float_t _roadFine;
  Float_t _roadCoarse;
  Float_t _roadOutFloor;
  Float_t _dca;
  Float_t _etaCentral;
  Float_t _phiCentral;
  bool _isCosmic;
  bool _isCosmicT;
  

public:
  
TMBMuon() {;}

  TMBMuon(Float_t pT, Float_t px, Float_t py, Float_t pz, Float_t E,
	  Float_t phi, Float_t tanl, Float_t eta, Float_t charge);
			
  void Set0(Float_t pT, Float_t px, Float_t py, Float_t pz, Float_t E,
	    Float_t phi, Float_t tanl, Float_t eta, Float_t charge);		

  void Set1(Int_t nhit, Int_t nseg, Int_t nmtc, 
	    Float_t chisq, Float_t deltaPhi, Float_t deltaEta, Float_t deltaDrift,
	    Float_t hfrac_hit, Float_t etrack_hit, Float_t hfrac_best, Float_t etrack_best,
	    Float_t elast, Float_t e33, Float_t e55, TRef chptr, TRef vtxref, 
	    Int_t ndeck, Int_t categoryloc, Int_t qualityloc, Int_t statusloc, 
	    Float_t chisqloc, Float_t qptloc, Int_t centralmatch, Int_t centralrank, 
	    Float_t sctimeA, Float_t sctimeBC,
	    Float_t scvelo, Int_t segIndex, Int_t TrkIndex, bool isTightMuoTrack);
  
  void Set2(Float_t xA, Float_t yA, Float_t zA, Float_t pxA, Float_t pyA, Float_t pzA,
	    Float_t phiA, Float_t etaA, 
	    Float_t zAtPca, Float_t impPar, Float_t impParSig, Float_t err_impPar, 
	    Float_t err_zAtPca, Float_t err_phi, Float_t err_tanLam, Float_t err_pT,
	    Float_t EInCone1, Float_t EInCone15, Float_t EInCone2, Float_t EInCone4, Float_t EInCone6, 
	    Int_t calnLayer, Float_t caleSig, Float_t calEta, Float_t calPhi,Int_t region, Int_t octant);
  
  
  void SetCandidateVariables(Float_t pTCorr, Int_t chargeCorr, Float_t pTCentral, Float_t eloss, 
			     Int_t expWhitsA, Int_t expWhitsBC, Int_t expShitsA, Int_t expShitsBC,
			     Int_t isLoose, Int_t isMedium, Int_t isTight, Int_t hasLocal, Int_t hasCentral, Int_t hasCal,
			     Int_t isAxialMatched, Float_t drJet5, Int_t nTrk5, Float_t etTrkCone5, Float_t etHalo,
			     Float_t bdl, Int_t isMuonEventOK, Float_t roadEM, Float_t roadFine, 
			     Float_t roadCoarse, Float_t roadOutFloor, Float_t dca,
			     Float_t etaC, Float_t phiC, bool isCos, bool isCosT);
  
  Float_t     px()      		const {return _px;}
  Float_t     py()      		const {return _py;}
  Float_t     pz()      		const {return _pz;}
  Float_t     E()       		const {return _E;}
  Float_t     charge()  		const {return _charge;}
  Float_t     pT()      		const {return _pT;}
  Float_t     eta()     		const {return _eta;}
  Float_t     phi()     		const {return _phi;}
  Float_t     tanl()        		const {return _tanl;}           
  Int_t       nhit()        		const {return _nhit;}
  Int_t       nseg()        		const {return _nseg;}
  Int_t       nmtc()        		const {return _nmtc;}
  Float_t     deltaPhi()    		const {return _deltaPhi;}
  Float_t     deltaEta()    		const {return _deltaEta;}
  Float_t     deltaDrift()  		const {return _deltaDrift;}
  Float_t     chisq()       		const {return _chisq;}
  Float_t     hfrac_hit()   		const {return _hfrac_hit;}
  Float_t     etrack_hit()  		const {return _etrack_hit;}
  Float_t     hfrac_best()  		const {return _hfrac_best;}
  Float_t     etrack_best() 		const {return _etrack_best;}
  Float_t     elast()       		const {return _elast;}
  Float_t     e33()         		const {return _e33;}
  Float_t     e55()         		const {return _e55;}
  const TMBTrks*    GetChargedTrack() const 	{return (TMBTrks*)_chptr.GetObject();}
  const TMBVrts*    GetVertex() const	{return (TMBVrts*)_vtxref.GetObject();}
  Int_t       ndeck()        		const {return _ndeck;} 
  Int_t       categoryloc()      	const {return _categoryloc;} 
  Int_t       qualityloc()      	const {return _qualityloc;} 
  Int_t       statusloc()        	const {return _statusloc;} 
  Float_t     centralmatch()            const {return _centralmatch;} 
  Int_t       centralrank()             const {return _centralrank ;} 
  Float_t     chisqloc()        	const {return _chisqloc ;} 
  Float_t     qptloc()        		const {return _qptloc ;} 
  Float_t     sctimeA()        		const {return _sctimeA ;} 
  Float_t     sctimeBC()        	const {return _sctimeBC ;} 
  Float_t     scvelo()        		const {return _scvelo ;} 
  Float_t     xA()        		const {return _xA ;} 
  Float_t     yA()        		const {return _yA ;} 
  Float_t     zA()        		const {return _zA;} 
  Float_t     pxA()        		const {return _pxA ;} 
  Float_t     pyA()        		const {return _pyA ;} 
  Float_t     pzA()        		const {return _pzA ;}
  Float_t     phiA()        		const {return _phiA ;} 
  Float_t     etaA()        		const {return _etaA ;} 
  Int_t       segIndex()        	const {return _segIndex ;} 
  Int_t       TrkIndex()        	const {return _TrkIndex ;} 
  bool 	      isTightMuoTrack()       const {return _isTightMuoTrack ;} 
  Float_t     zAtPca()        		const {return _zAtPca ;} 
  Float_t     impPar()        		const {return _impPar ;} 
  Float_t     impParSig()        	const {return _impParSig ;} 
  Float_t     err_impPar()              const {return _err_impPar;} 
  Float_t     err_zAtPca()              const {return _err_zAtPca ;}
  Float_t     err_phi()        		const {return _err_phi ;} 
  Float_t     err_tanLam()              const {return _err_tanLam ;} 
  Float_t     err_pT()        		const {return _err_pT ;}

  Float_t     EInCone1()                const {return _EInCone1;}
  Float_t     EInCone15()               const {return _EInCone15;}
  Float_t     EInCone2()                const {return _EInCone2;}
  Float_t     EInCone4()                const {return _EInCone4;}
  Float_t     EInCone6()                const {return _EInCone6;}
  Int_t       calnLayer()               const {return _calnLayer;}
  Float_t     caleSig()                 const {return _caleSig;}
  Float_t     calEta()                  const {return _calEta;}
  Float_t     calPhi()                  const {return _calPhi;}

  Int_t       region()                  const {return _region;}
  Int_t       octant()                  const {return _octant;}

  Float_t pTCorr()       const { return _pTCorr;}
  Int_t chargeCorr()     const { return _chargeCorr;}
  Float_t pTCentral()    const { return _pTCentral;}
  Float_t eloss()        const {return _eloss;}
  Int_t expWhitsA()      const {return _expWhitsA;}
  Int_t expWhitsBC()     const {return _expWhitsBC;}
  Int_t expShitsA()      const { return _expShitsA;}
  Int_t expShitsBC()     const { return _expShitsBC;}
  Int_t isLoose()        const { return _isLoose;}
  Int_t isMedium()       const { return _isMedium;}
  Int_t isTight()        const {return _isTight;}
  Int_t hasLocal()       const {return _hasLocal;}
  Int_t hasCentral()     const {return _hasCentral;}
  Int_t hasCal()         const {return _hasCal;}
  Int_t isAxialMatched() const {return _isAxialMatched;}
  Float_t drJet5()       const {return _drJet5;}
  Int_t nTrk5()          const {return _nTrk5;}
  Float_t etTrkCone5()   const {return _etTrkCone5;}
  Float_t etHalo()       const {return _etHalo;}
  Float_t bdl()          const {return _bdl;}
  Int_t isMuonEventOK()  const {return _isMuonEventOK;}
  Float_t roadEM()       const {return _roadEM;}
  Float_t roadFine()     const {return _roadFine;}
  Float_t roadCoarse()   const {return _roadCoarse;}
  Float_t roadOutFloor() const {return _roadOutFloor;}
  Float_t dca()          const {return _dca;}
  Float_t etaCentral() const {return _etaCentral;}
  Float_t phiCentral() const {return _phiCentral;}
  bool isCosmic() const {return _isCosmic;}
  bool isCosmicT() const {return _isCosmicT;}

  ~TMBMuon() {;}
  
  ClassDef(TMBMuon, 3)   //TMBTree Muon class
    };

#endif