#ifndef TAU_TStnTau
#define TAU_TStnTau

#include <vector>

#include "TClonesArray.h"

class CdfTau;
class TStnElectron;
class TStnTrack;
class TStnMuon;
class StnTausBlock_t;
class TYbosBank;

#include "TStnLepton.hh"

class TStnTau: public TStnLepton {

  friend Int_t StnRun1InitTau(TStnTau*        Tau, 
			      StnTausBlock_t* R1Tau, 
			      Int_t           Itau);
public:
					// ****** public constants
					// tau decay modes
  enum {
    kElectronMode = 1,
    kMuonMode     = 2,
    kHadronicMode = 3
  };

public:

  TLorentzVector fClusterMomentum;	// momentum by cal cluster
  TLorentzVector fTrackMomentum;	// track-only momentum
  TLorentzVector fVisMomentum;		// tracks + pi0's
  TLorentzVector fGenpMomentum;		// ! generated 4-momentum
//-----------------------------------------------------------------------------
// ******* SHORT INTEGERS ********
//-----------------------------------------------------------------------------
  Short_t        fDecayMode;
  Short_t        fNumber;

  Short_t        fNTracks10;            // Ntrk (tau)
  Short_t        fNTracks30;		// Ntrk assoc-d with tau (tau + iso(with pt>1) )
// note: in general fNTracks30 <= TStnTauBlock::TrackLinkList()->NLinks (tau#)
// as TrackLinkList also contains ISO tracks with pt<1

// the following four are not implemented:
  Short_t        fNWrongTracks;		// # tracks from the wrong vertex
  Short_t        fNExtrapTracks;	// 
  Short_t        fNExtrapTracks10;
  Short_t        fNExtrapTracks30;

// these three are only for RunI taus
  Short_t        fClslNumber;		// # of the corresponding CLSL bank
  Short_t        fJetsNumber;		// # of the corresponding JETS bank
  Short_t        fTauoNumber;		// # of the TAUO bank (Run I)

  Short_t        fNL2Towers;		// N(L2-like towers) in the cluster (not implem-d)
  Short_t        fNTowers;		// N(cal towers) in the cluster

  Short_t        fNPi010;		// # of Tau's pi0s
  Short_t        fNPi01030;		// Npi0s in ISO (with Et>0.5)
// note: in general fNPi010+fNPi01030 <= TStnTauBlock::Pi0LinkList()->NLinks (tau#)
// as Pi0LinkList also contains ISO pi0s with et<0.5

  Short_t        fNTrkTau;		// N(tracks) for the cluster M < M_tau 
                                        // (not implem-d)

  Short_t        fNMuStubs;		// # of muon stubs 
  Short_t        fNMuHits;		// # of muon hits

//-----------------------------------------------------------------------------
// ****************** FLOATS *********
//-----------------------------------------------------------------------------
  Float_t        fStatusCode;           // (obsolete)

  Float_t        fDteta;                // Detector eta of the cluster
  Float_t        fEtaEta;		// eta-eta moment of the cal cluster
  Float_t        fPhiPhi;		// phi-phi moment of the cal cluster

  Float_t        fEtEm;			// cal-only EM Et
  Float_t        fEtHad;		// cal-only HAD Et
  Float_t        fEmfr;			// EM fraction of calor cluster

  Float_t        fSumPt30;		// scalar sum(Pt) of tracks in ISO annulus 
                                        // or continuous track isolation
  Float_t        fSumPtPi030;		// scalar sum(Pt) of pi0s in ISO annulus 
                                        // or continuous pi0 isolation

  Float_t        fSeedTrackZ;		// Z(vertex) of the seed track
  Float_t        fSeedTrackPt;		// Pt of the seed track
  Float_t        fSeedDeltaPhi;		// delta(phi) cluster - seed track

  Float_t        fSumTrackP;		// scalar sum of trk momenta (not Pt's!) (tau cone)
  Float_t        fSumPt10;		// scalar sum of trk Pt's (tau cone)

  Float_t        fEmIso04;		// EM Et(cone 0.4) - EM Et(tau)
  Float_t        fHadIso04;		// HAD Et(cone 0.4) - HAD Et(tau)

  Float_t        fTrackIso;		// track isolation between 10-30 deg 
                                        // recalculated in StntupleTauBlockLinks 
					// - not recommended, use fSumPt30
  
  Float_t        fECorrectionFactor;	// factor to correct Vis Pt
  Float_t        fTauCone;      	// cone value used for tau tracks
  Float_t        fTauConePi0;      	// cone value used for tau pi0s
  Float_t        fTowerEt[2];	        // Et of the 2 highest towers  
  
  const CdfTau*  fCdfTau;		// ! transient-only backward pointer
//-----------------------------------------------------------------------------
// transient-only data members (sometimes redundant but kept for compatibility)
// not streamed, but are set by TStnTau::PostReadV4
//-----------------------------------------------------------------------------

  Short_t        fNTracks;		// the same as fNTracks30
  Short_t        fNPi0;			// the same as fNPi010 - yes, it's confusing
  					// but have to keep it so for compatibility
  
  Float_t        fDelr;                 // DR-DR moment of the cal cluster
  Float_t        fCalIso04;		// calorimetry isolation in cone 0.4
  Float_t        fZv;                   // currently the same as fSeedTrackZ
  					// for compatibility reason

//-----------------------------------------------------------------------------
// transient-only data members -
// make sure you set them at run-time before you started using them
//-----------------------------------------------------------------------------
  TStnTrack*     fSeedTrack;		// !
  Float_t        fSeedTrackXCes;	// ! extrapolated to CES
  Float_t        fSeedTrackZCes;	// ! extrapolated to CES
  Float_t        fSeedTrackD0;	        // ! 
  Float_t        fDelXCes;		// !
  Float_t        fDelZCes;		// !
  Float_t        fMaxTrkAngle;		// !
  Float_t        fMaxPi0Angle;		// !
  Float_t        fTmp[50];              // ! buffer for temporary analysis needs
  Int_t          fLooseIDWord;	        // !
  TObjArray*     fListOfTracks;         // ! transient-only arrays
  TObjArray*     fListOfPi0s;           // !

  Float_t        fZeta;                 // ! CalEt/SumPt10*(1-EtEm/CalEt)
  Int_t          fJetNumber;            // ! index in JetBlock
  Float_t        fDZVrt;                // ! Delta Z to the event vertex
  Int_t          fGenpEleNumber;        // ! closest GENP electron number
  Int_t          fGenpMuoNumber;        // ! closest GENP electron number

  //  Float_t        fMass;
  //  Float_t        fPtvis;
  //  Float_t        fTrackEta;		// eta of the track cluster
  //  Float_t        fTrackPhi;		// phi of the track cluster
  //  Float_t        fTrackMass;	// mass of the track cluster
  //  Float_t        fMet;		// Missing(Et) using the tau Z(vertex)
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
public:

  TStnTau(Int_t Number = -1);
					// new tau -> hadronic (gen. level)
  TStnTau(GENP_PARTICLE* p);
					// start from FINDTAU (TAUO bank)
  TStnTau(TYbosBank* tau, int i);
					// new tau -> e nu nu
  TStnTau(TStnElectron* ele);
					// new tau -> mu nu nu
  TStnTau(TStnMuon*     muo);
  ~TStnTau();

  void            InitTransientArrays();
//-----------------------------------------------------------------------------
// accessors
//-----------------------------------------------------------------------------

  Int_t           Number         () const { return fNumber;           }
  Int_t           Type           () const { return TStnLepton::kTau;  }
  Int_t           DecayMode      () const { return fDecayMode;  }
  Int_t           NTracks        () const { return fNTracks;    }
  Int_t           NTracks10      () const { return fNTracks10;  }
  Int_t           NTracks30      () const { return fNTracks30;  }
  Int_t           NTracks1030    () const { return fNTracks30-fNTracks10;  }
  Int_t           NPi010         () const { return fNPi010;     }
  Int_t           NPi01030       () const { return fNPi01030;   }
  Int_t           NTowers        () const { return fNTowers;    }
  Int_t           NL2Towers      () const { return fNL2Towers;  }
  Int_t           NPi0           () const { return fNPi0;       }
  Int_t           NMuStubs       () const { return fNMuStubs;   }
  Int_t           NMuHits        () const { return fNMuHits;    }
  Int_t           JetsNumber     () const { return fJetsNumber; }
  Int_t           ClslNumber     () const { return fClslNumber; }

//-----------------------------------------------------------------------------
// Jun 10 2002 P.Murat: this is an approximation and implementation should be 
// done better: check if the seed tower is central, but the accessor is useful
//-----------------------------------------------------------------------------
  Int_t           IsCentral      () const { 
    return (TMath::Abs(fDteta) < 1.2);
  }
					// reusing fClslNumber

  Int_t           ObjectType     () const { return fClslNumber; }
  Int_t           TauoNumber     () const { return fTauoNumber; }

  TLorentzVector* ClusterMomentum()       { return &fClusterMomentum;    }
  Double_t        Mass           () const { return fClusterMomentum.M(); }

  TLorentzVector* TrackMomentum  ()       { return &fTrackMomentum;    }
  Float_t         TrackMass      () const { return fTrackMomentum.M(); }

  TLorentzVector* VisMomentum    ()       { return &fVisMomentum;      }
  Double_t        PtVis          () const { return fVisMomentum.Pt();  }
  Double_t        VisMass        () const { return fVisMomentum.M ();  }

  Double_t        VisEt          () const { 
    return fVisMomentum.E()*fVisMomentum.Pt()/fVisMomentum.P();  
  }
  Float_t      ECorrectionFactor () const { return fECorrectionFactor; }
  Double_t     VisEtCorr         () const { return VisEt()*ECorrectionFactor();}

  TLorentzVector* GenpMomentum   ()       { return &fGenpMomentum;     }
  const CdfTau*   GetCdfTau      () const { return fCdfTau; }

  Float_t         StatusCode     () const { 
    Error("StatusCode","Obsolete, do not use. -Pasha");
    return -1; 
  }
//-----------------------------------------------------------------------------
//  **************** kludge!
//-----------------------------------------------------------------------------
  Int_t           IDWord         () const { return (Int_t) fStatusCode; }
  Int_t           LooseIDWord    () const { return fLooseIDWord;        }

  Double_t        Zv             () const { return fZv;         }
  Float_t         EtEm           () const { return fEtEm;       }
  Float_t         EtHad          () const { return fEtHad;      }
  Float_t         Et             () const { return fEtEm+fEtHad;}
  Float_t         CalEt          () const { return fEtEm+fEtHad;}
  Double_t        Emfr           () const { return fEmfr;       }
  Float_t         DetEta         () const { return fDteta;      }
  Double_t        EtaEta         () const { return fEtaEta;     }
  Double_t        PhiPhi         () const { return fPhiPhi;     }
  Float_t         Delr           () const { return fDelr;       }
  Float_t         SumTrackP      () const { return fSumTrackP;  }
  Float_t         SumPt10        () const { return fSumPt10;    }
  Float_t         SumPt30        () const { return fSumPt30;    }
  Float_t         SumPtPi030     () const { return fSumPtPi030;	}
  Double_t        SeedTrackPt    () const { return fSeedTrackPt;}
  Double_t        SeedTrackZ     () const { return fSeedTrackZ;}
  Double_t        SeedDPhi       () const { return fSeedDeltaPhi;}
  Float_t         EOverP         () const { return CalEt()/SeedTrackPt(); }
  Float_t         EmEp           () const { return EtEm ()/fTrackMomentum.Pt(); }
  Float_t         HadEp          () const { return EtHad()/fTrackMomentum.Pt(); }

  Float_t         TowerEt   (int i) const { return fTowerEt[i]; }

  Float_t         CalIso04       () const { return fCalIso04;   }
  Float_t         EmIso04        () const { return fEmIso04;    }
  Float_t         HadIso04       () const { return fHadIso04;   }
  Float_t         TrackIso       () const { return fTrackIso;   }

  Float_t         CalIso1() const { return fCalIso04/fClusterMomentum.Pt(); }
  Float_t         TrkIso1() const { return fTrackIso/fTrackMomentum.Pt()  ; }
//-----------------------------------------------------------------------------
//  accessors for transient-only variables, defined within the analysis job
//-----------------------------------------------------------------------------
  Float_t         SeedTrackXCes  () const { return fSeedTrackXCes; }
  Float_t         SeedTrackZCes  () const { return fSeedTrackZCes; }
  Float_t         SeedTrackD0    () const { return fSeedTrackD0;   }
  Float_t         DelXCes        () const { return fDelXCes;       }
  Float_t         DelZCes        () const { return fDelZCes;       }
  Float_t         MaxPi0Angle    () const { return fMaxPi0Angle;   }
  Float_t         MaxTrkAngle    () const { return fMaxTrkAngle;   }
  Float_t         Zeta           () const { return fZeta;          }
  Int_t           JetNumber      () const { return fJetNumber;     }
  Float_t         DZVrt          () const { return fDZVrt;         }
  Float_t&        Tmp     (Int_t i)       { return fTmp[i];        }
  Int_t           GenpEleNumber  () const { return fGenpEleNumber; }
  Int_t           GenpMuoNumber  () const { return fGenpMuoNumber; }

  TStnTrack*      SeedTrack      () const { return fSeedTrack;     }
  TObjArray*      GetListOfTracks() const { return fListOfTracks;  }
  TObjArray*      GetListOfPi0s  () const { return fListOfPi0s;    }

				// set tau parameters using the results stored
				// in /TAUCOMMON/

  void            InitFromTaucommon(int itau);
//-----------------------------------------------------------------------------
// modifiers
//-----------------------------------------------------------------------------
  void IncrementNTracks()                { fNTracks++; fNTracks30++; }
  void IncrementNPi0   ()                { fNPi0++;    fNPi010++; }
  void AddCharge       (Double_t charge) { fCharge += charge;     }

  void SetSeedTrackPt  (Double_t   Pt  ) { fSeedTrackPt   = Pt;   } 
  void SetDecayMode    (Int_t      Mode) { fDecayMode     = Mode; }
  void SetTrackIso     (Double_t   Iso ) { fTrackIso      = Iso;  }
  void SetObjectType   (Int_t      Type) { fClslNumber    = Type; }
  void SetJetsNumber   (Int_t      I   ) { fJetsNumber    = I;    }
  void SetSumTrackP    (Float_t    Sum ) { fSumTrackP     = Sum;  }
  void SetStatusCode   (Float_t    Code) { fStatusCode    = Code; }
  void SetSeedTrack    (TStnTrack* Trk ) { fSeedTrack     = Trk;  }

  void SetSeedTrackXCes(Float_t    XCes) { fSeedTrackXCes = XCes; }
  void SetSeedTrackZCes(Float_t    ZCes) { fSeedTrackZCes = ZCes; }
  void SetSeedTrackD0  (Float_t    d0)   { fSeedTrackD0   = d0; }

  void SetNPi010       (Int_t      N   ) { 
    fNPi010        = N;    
    fNPi0          = N;    
  }

  void SetNPi01030     (Int_t      N    ) { fNPi01030      = N;    }
  void SetNTracks10    (Int_t      N    ) { fNTracks10     = N;    }

  void SetNTracks30    (Int_t      N    ) { 
    fNTracks30     = N;
    fNTracks       = N;    
  }

  void SetMaxPi0Angle  (Float_t    DPhi ) { fMaxPi0Angle   = DPhi;  }
  void SetMaxTrkAngle  (Float_t    DPhi ) { fMaxTrkAngle   = DPhi;  }
  void SetDelZCes      (Float_t    DelZ ) { fDelZCes       = DelZ;  }
  void SetDelXCes      (Float_t    DelX ) { fDelXCes       = DelX;  }
  void SetZeta         (Float_t    zeta ) { fZeta          = zeta;  }
  void SetJetNumber    (Int_t      ijet ) { fJetNumber     = ijet;  }
  void SetDZVrt        (Float_t    Dz   ) { fDZVrt         = Dz;    }
  void SetEmfr         (Float_t    Emfr ) { fEmfr          = Emfr;  }
  void SetEtEm         (Float_t    EtEm ) { fEtEm          = EtEm;  }
  void SetEtHad        (Float_t    EtHad) { fEtHad         = EtHad; }
  void SetEmIso04      (Float_t    Iso  ) { fEmIso04       = Iso;   }
  void SetHadIso04     (Float_t    Iso  ) { fHadIso04      = Iso;   }
  void SetCalIso04     (Float_t    Iso  ) { fCalIso04      = Iso;   }
  void SetEtaEta       (Float_t    Rms  ) { fEtaEta        = Rms;   }
  void SetPhiPhi       (Float_t    Rms  ) { fPhiPhi        = Rms;   }
  void SetDelr         (Float_t    Rms  ) { fDelr          = Rms;   }
  void SetGenpEleNumber(Int_t      Index) { fGenpEleNumber = Index; }
  void SetGenpMuoNumber(Int_t      Index) { fGenpMuoNumber = Index; }

  //
  // ************** will add ID word soon

  void SetIDWord     (Int_t   Code) { fStatusCode  = (Float_t) Code; }
  void SetLooseIDWord(Int_t   Code) { fLooseIDWord = Code;           }
//-----------------------------------------------------------------------------
// overloaded methods of TObject
//-----------------------------------------------------------------------------
  void Print(Option_t* opt = "") const;

protected:

  void            LoopOverDaughters(GENP_PARTICLE* mc);
  
//-----------------------------------------------------------------------------
// schema evolution
//-----------------------------------------------------------------------------
  void ReadV2(TBuffer &R__b);
  void ReadV3(TBuffer &R__b);
  void ReadV4(TBuffer &R__b);

  ClassDef(TStnTau,5)
};

#endif