///------------------------------------------------------------
// Description:
// ------------
//
//	Declarations of objects used
//      by TopNtuple.cc and ana.cc
//
//      Can be used by any other class.
//      Simply include the file:
//
//  #include HighLevelObjects.hh
//
//      and compile/load the shared library:
//
//  gSystem->CompileMacro("HighLevelObjects.cc","k");
//
//------------------------------------------------------------

#include "TObject.h"
#include <iostream>
#include <ctime>

//----------------------------------
// Event
//----------------------------------
class evt : public TObject {
  public:
  
  evt();
  ~evt() {};
  
  int runNumber;
  int eventNumber;
  int CosmicOOTLow;

  double gliveInstLumi;
  double gliveTotalLumi;
  double instLumi;
  double totalLumi;
  double scalerInstLumi;
  double scalerTotalLumi;
 
  // time stamp
  time_t creationTime;
 
   ClassDef(evt,4) 
  //ClassDef(evt,5) 
};

//----------------------------------
// Summary
//----------------------------------
class summary : public TObject {
  public:
  
  summary();
  ~summary() {};
  
  int fTopEventClass;
  int fnTightEle;
  int fnLooseEle;
  int fnTightMuo;
  int fnLooseMuo;
  int fnTightLepton;
  int fnLooseLepton;
  int fnTightJet;
  int fnLooseJet;
  //
  float frawMet;
  float frawMetPhi;
  float fvtxMet;
  float fvtxMetPhi;
  float fmuoMet;
  float fmuoMetPhi;
  float fhadSumEt;
  float fhadSumEt3;
  float fhadCentrality;
  float fhadAplanarity;
  float fhadSphericity;

  float fprimZV;
  float fjetZV;
  float fprimZVerr;
  float fjetZVerr;

  float fdileptonHT;
  float flepjetsHT;
   
  ClassDef(summary,3) 
};

//---------------------------------- 
// Primary Vertex
//----------------------------------
class privertex : public TObject {
  public:
  
  privertex();
  ~privertex() {};
  
  float sbm_x0; //Svx beam x coordinate at z=0
  float sbm_y0;
  float sbm_slx; //Svx beam x slope 
  float sbm_sly;
  float cbm_x0; //Cot beam x coordinate at z=0
  float cbm_y0;
  float cbm_slx; //Cot beam x slope 
  float cbm_sly;  
  
  float x;
  float y;
  float z;
  float covxx;
  float covyy;
  float covzz;
  float covxy;
  float covxz;
  float covyz;
  float mcx;
  float mcy;
  float mcz; 
 
  float SecVtxVx;
  float SecVtxVy;
  float SecVtxVz;
  float SecVtxC11;
  float SecVtxC22;
  float SecVtxC33;
  float SecVtxC12;
  float SecVtxC13;
  float SecVtxC23;

  ClassDef(privertex,2) 
};

//---------------------------------- 
// Event ZVertices
//----------------------------------
class zvtxs : public TObject {

  public:
  
  zvtxs();
  ~zvtxs() {};
  
  float z_pos;
  float z_err;
  int   n_trk;
  float sum_pt;
  int   quality;
 
  ClassDef(zvtxs,1) 
};


//---------------------------------- 
// Secondary Vertex Track
//----------------------------------
class secvtxtrack : public TObject {
  public:
  
  secvtxtrack();
  ~secvtxtrack() {};

  int   tNgHitx;
  int   tNgHitz;
  int   tNgHitSz;

  unsigned int tId;
  float sPt;
  float tEta;
  //input track parameters

  float tCur;
  float tPhi0;
  float tD0;
  float tZ0;
  float tCot;
  float tCurE;
  float tPhi0E;
  float tD0E;
  float tZ0E;
  float tCotE;


  float sD0;
  float sD0s; 
  float sZ0;
  float sZ0s;
  float sChi2X;
  int   sNHitX;
  int   sNHitSZ;
  int   sNHitZ;
  int   sType;
  int   nCotHits;
  //  float Vx;
  //  float Vy;
  //  float Vz;
  
  ClassDef(secvtxtrack,1) 
};


//---------------------------------- 
// JetProb Track
//----------------------------------
class jetprobtrack : public TObject {
  public:
  
  jetprobtrack();
  ~jetprobtrack() {};

  unsigned int tId;
  float tPt;
  float tTheta;
  float tEta;
  float tPhi0;
  int tNSvxLayer;
  int tNSvxHit;
  int tNSvxPhiHit;
  int tNSvxStHit;
  int tNSvxZHit;
  int tTotNSvxRPhiHit; // svx only
  int tTotNGdSvxRPhiHit; // svx only
  float tD0;
  float tD0Err;
  float tSignD0;
  float tZ0;
  float tZ0Err;
  float tSignZ0;
  float tProbRPhi;
  float tProbRZ;
  float tProb3D;
  int tNCotHit;
  int tNCotAxHit;
  int tNCotStHit;
  int tTrackQtyRPhi;
  int tTrackQtyRZ;
  int tLongLiveFlagRPhi;
  int tLongLiveFlagRZ;
  int tIsGoodRPhi;
  int tIsGoodRZ;

  ClassDef(jetprobtrack,1) 
};


//----------------------------------
// Trigger Info
//----------------------------------
class trigInfo : public TObject {
  public:
  
  trigInfo();
  ~trigInfo() {};

   int L1W1NoPS;
   int L1W2NoPS;
   int L1W1PS;
   int L1W2PS;
   int L2W1;
   int L2W2;
   int L2W3;
   int L2W4;
   int L2W1NoPS;
   int L2W2NoPS;
   int L2W3NoPS;
   int L2W4NoPS;
   int L3W1;
   int L3W2;
   int L3W3;
   int L3W4;
   int L3W5;
   int L3W6;

  ClassDef(trigInfo,2) 
};


//----------------------------------
// Trigger Name
//----------------------------------
class trigName : public TObject {
  public:
  
  trigName();
  ~trigName() {};

   int RunNumber;
	
   int NumL1Triggers;
   int NumL2Triggers;
   int NumL3Triggers;
	
   int  L1Bit[64];
   int  L2Bit[128];
   int  L3Bit[256];
	
   char L1Name[64][64];
   char L2Name[128][64];
   char L3Name[256][64];

  ClassDef(trigName,1) 
};


//----------------------------------
// Missing Et
//----------------------------------
class missingEt : public TObject {
  public:
  
  missingEt();
  ~missingEt() {};

  float Met;
  float Phi;
  float ZV;
  float ESum;
  float EtSum;
  float ExSum;
  float EySum;

  ClassDef(missingEt,1) 
};


//----------------------------------
// HEPG Bank
//----------------------------------
class hepg : public TObject {
  public:
  
  hepg();
  ~hepg() {};
  
  int Ind;
  int ID;
  int IDparent;
  int Stdhep;
  int Mo1; //jmo1hep -1
  int Mo2; //jmo2hep -1
  int Da1; //jda1hep -1
  int Da2; //jda2hep -1
  float Charge;
  float Px;
  float Py;
  float Pz;
  float E;
  float Mass;
 
  ClassDef(hepg,6) 
};


//----------------------------------
// OBSP Bank
//----------------------------------
class obsp : public TObject {
  public:
  
  obsp();
  ~obsp() {};

  int cdfid;
  int hepglink;
  int dkmode;
  double px;
  double py;
  double pz;
  double m;
  double qcharge;
  double path;
  int motherid;
  int nda;
  double Vx;
  double Vy;
  double Vz;
  double Vt;
  int is_bdaughter;
  int is_cdaughter;
  int beauty;
  int charm;

  ClassDef(obsp,1) 
};


//----------------------------------
// Electron
//----------------------------------
class electron : public TObject {
  public:
  
  electron();
  ~electron() {};
 
  int CollType;
  int Region;
  int Conversion;
  
  float En;       float RawEn;       float CluEn;
  float Px;       float RawPx;       float CluPx;
  float Py;       float RawPy;       float CluPy;
  float Pz;       float RawPz;       float CluPz;
  float Et;       float RawEt;       float CluEt;
  float Phi;      float RawPhi;      float CluPhi;
  float Eta;      float RawEta;      float CluEta;
  
  int TrkSiHits;
  int TrkAxHits;
  int TrkStHits;
  int TrkAxSeg;
  int TrkStSeg;

  float TrkP;     float BCP;         float RawTrkP;
  float TrkPx;    float BCPx;        float RawTrkPx;
  float TrkPy;    float BCPy;        float RawTrkPy;
  float TrkPz;    float BCPz;        float RawTrkPz;
  float TrkPt;    float BCPt;        float RawTrkPt;
  float TrkEta;   float BCEta;       float RawTrkEta;
  float TrkPhi0;  float BCPhi0;      float RawTrkPhi0;
  float TrkZ0;    float BCZ0;        float RawTrkZ0;
  float Charge;   float BCCharge;    float RawTrkCharge;
  float TrkD0;

  int TrkID;
  int Fiducial;
  int TrkFiducial;

  float EtaDet;
  float EtaEvent;//added djg
  float HadEt;
  float TotalEt;
  float Hadem;
  float EmEt;
  float HadEn;
  float TotalEn;
  float TotalIsol4;
  float TotalIsol7;
  float EmIsol4;
  float EmIsol7;
  float HadIsol4;
  float HadIsol7;

  float PprEn;//added djg
  int   Pem3x3FitTow;//added djg
  float Pem3x3DetEta;//added djg
  float Pem3x3Phi;//added djg
  float Pem3x3FitEn;//added djg
  float Pem3x3Chisq;//added djg

  int   NumPes2d;//added djg
  float Pes2dEta;//added djg
  float Pes2dPhi;//added djg
  float Pes2dX;//added djg
  float Pes2dY;//added djg
  float Pes2d5by9U;//added djg
  float Pes2d5by9V;//added djg
  float Pes2dEn;//added djg

  float ClosestPes2d5by9U;//added djg
  float ClosestPes2d5by9V;//added djg
  float ClosestPes2dEn;//added djg

  //            example on fcdflnx2:~daveg/491hpt1_use_topcode
  //  float Pes2dUEne;
  //float Pes2dVEne;
  // other quantites of general interest
  //float EmPhi;
  //MT 01-2003 PesQuantites finished

  float LshrTrk;
  float Lshr3;
  float Lshr2;
  
  float Isol;
  float LeakE;
  float EP;
  float EventZVertex;
  float DeltaZVertex;
  
  float TrkCESx;
  float BestCESx;
  float DeltaX;

  float TrkCESz;
  float BestCESz;
  float DeltaZ;

  float StripChi2;  
  float WireChi2;

  float TrkIsol;

  int Towers;
  int Tracks;
  int SeedEta;
  int SeedPhi;
  float SeedEn;//added djg
  float SeedEt;//added djg

  //MT 04-2003 Added photon variables
  float PhoZV;
  float PhoRawEn;
  float PhoRawEt;
  float PhoEt;
  float PhoPhi;
  float PhoEta;
  float PhoCESx;
  float PhoCESz;
  float PhoEneStrip;
  float PhoEneWire;
  float PhoStripChi2;
  float PhoWireChi2;
  float PhoCES2x;
  float PhoCES2z;
  float PhoEneStrip2;
  float PhoEneWire2;
  float PhoCesSlide;
  int   PhoN3D;
  float PhoPt;
  float PhoIsol;
  float PhoTrkIsol;
  float PhoLshr;
  float PhoHadem;

  float RawEnergyWire;
  float RawEnergyStrip;
  float FitEnergyWire;
  float FitEnergyStrip;
  int CESside;
  int CESmodule;
  int TrkCESside;
  int TrkCESmodule;
  
  int CPR;
  int CPRside;
  int CPRmodule;
  int TrkCPRside;
  int TrkCPRmodule;
  
  float CPRx;
  float DeltaXCPR;
  float RawEnergyCPR;
  float TrkCPRx;
  float TrkCPRz;
  float TrkCPRphi;
  float TrkCPReta;
  
  float WidthWire;
  float WidthStrip;

  float CheckEn;
  float CheckPx;
  float CheckPy;
  float CheckPz;
  float CheckZ0;
  float CheckZ0Err;
  int CheckConv;
  int CheckTrkId;
  int CutCode;

  // Phoenix
  int PhxTrkSiHits;

  float PhxTrkP;
  float PhxTrkPx;
  float PhxTrkPy;
  float PhxTrkPz;
  float PhxTrkPt;
  float PhxTrkEta;
  float PhxTrkPhi0;
  float PhxTrkZ0;
  float PhxCharge;
  float PhxTrkD0;

  bool PhxMatch;
  int PhxCotMatchID;

  float BruceLLK;
	  
  ClassDef(electron,15) 
};


//----------------------------------
// Muon
//----------------------------------
class muon : public TObject {
  public:
  
  muon();
  ~muon() {};
 
  int ViewType;
  int muontype;
  int Fiducial;
  // MT 04/03
  int TrkFiducial;

  float En;
  float P;
  float Px;
  float Py;
  float Pz;
  float Pt;
  float Eta;
  float Phi0;
  float Z0;
  float Charge;
  float D0;

  float BCP;
  float BCPx;
  float BCPy;
  float BCPz;
  float BCPt;
  float BCEta;
  float BCPhi0;
  float BCZ0;
  float BCCharge;

  float RawP;
  float RawPx;
  float RawPy;
  float RawPz;
  float RawPt;
  float RawEta;
  float RawPhi0;
  float RawZ0;
  float RawCharge;
  
  int TrkSiHits;
  int TrkAxHits;
  int TrkStHits;
  int TrkAxSeg;
  int TrkStSeg;
  int TrkID;
  float HadEnergy;
  float EmEnergy;
  float EventZVertex;
  float DeltaZVertex;
  float Isol;
  float EmIsol4;
  float HadIsol4;
  float TotalIsol4;
  float EmIsol7;
  float HadIsol7;
  float TotalIsol7;
  float TrkIsol;

  float CmuDx;
  float CmpDx;
  float CmxDx;
  float BmuDx;
  float Dx[4];
  int Wedge[4];
  int Side[4];
  int NumAssHits[4];

  float CheckEn;
  float CheckPx;
  float CheckPy;
  float CheckPz;
  float CheckZ0;
  float CheckZ0Err;
  float CheckD0;
  int CheckTrkId;
  int CutCode;

  float BruceLLK;

  ClassDef(muon,8) 
};


//----------------------------------
// Jet
//----------------------------------
class jet : public TObject {
  public:
  
  jet();
  ~jet() {};

  int   CollType;

  float Px;
  float Py;
  float Pz;
  float En;

  float EtaDetector;
  float GuardEnergy;
  float EmFraction;
  float CentroidEta;
  float CentroidPhi;
  float EtaMoment;
  float PhiMoment;
  float EtaPhiMoment;
  float CentroidEt;
  float TotP;
  float TotPt;
  float Pt;
  float PtSquared;
  float TotEt;
  float Et;
  float Eta;
  float Theta;
  float Phi;
  float MassSquared;
  float Mass;
  float Rapidity;

  float secvTag;
  float secvPass;
  float secvCharge;
  float secvL3d;
  float secvDl3d;
  float secvL2d;
  float secvDl2d;
  float secvLzd;
  float secvDlzd;
  float secvChisq;
  float secvChisqr;
  float secvChisqz;
  float secvNtrk;
  float secvNdtrk;
  float secvNvtrk;
  float secvMass;
  float secvPt;
  float secvX;
  float secvY;
  float secvZ;
  float secvXerr;
  float secvYerr;
  
  int NTracks;

  // number of JPB tracks associated to jet 
  int jpbNTracks;
  float jpbJetEt;
  float jpbJetEta;
  float jpbJetPhi;
  // tags
  int jpbHFTag;
  int jpbHFHepId;
  float jpbHFdR;
  // variables concerning jet probability fin R-Phi plane
  float jpbRPunsign;   // Jet-Probability value using tracks 
                              // with +/- signed impact parameter
  float jpbRPpos;      // Jet-Probability value using tracks 
                              // with + signed impact parameter 
  float jpbRPneg;      //Jet-Probability value using tracks 
                              // with - signed impact parameter 
  int jpbNGdRPTrk;    // Number of good tracks with +/- signed
  int jpbNGdRPTrkPos; // Number of good tracks with + signed
  int jpbNGdRPTrkNeg; // Number of good tracks with - signed
  // variables concerning jet probability fin R-Z plane
  float jpbRZunsign;   // Jet-Probability value using tracks 
                              // with +/- signed impact parameter
  float jpbRZpos;      // Jet-Probability value using tracks 
                              // with + signed impact parameter 
  float jpbRZneg;      //Jet-Probability value using tracks 
                              // with - signed impact parameter 
  int jpbNGdRZTrk;    // Number of good tracks with +/- signed
  int jpbNGdRZTrkPos; // Number of good tracks with + signed
  int jpbNGdRZTrkNeg; // Number of good tracks with - signed
  // variables concerning jet probability fin R-Z plane
  float jpb3Dunsign;   // Jet-Probability value using tracks 
                              // with +/- signed impact parameter
  float jpb3Dpos;      // Jet-Probability value using tracks 
                              // with + signed impact parameter 
  float jpb3Dneg;      //Jet-Probability value using tracks 
                              // with - signed impact parameter 
  int jpbNGd3DTrk;    // Number of good tracks with +/- signed
  int jpbNGd3DTrkPos; // Number of good tracks with + signed
  int jpbNGd3DTrkNeg; // Number of good tracks with - signed

  ClassDef(jet,6) 
};




//----------------------------------
// Offline Track
//----------------------------------
class offltrack : public TObject {
  public:
  
  offltrack();
  ~offltrack() {};

  int   CollType; 
  int   PassesDefTrkCut; 
  int   ObspId;

  float Pt;
  float Id;
  float NumCTHitsAx;
  float NumCTHitsSt;
  float NumAxSeg;
  float NumStSeg;
  float Lambda;
  float Curv;
  float Z0;
  float D0;
  float Phi0;
  
  float SIHits;
  float SIFit;
  float SIGoodHitX;
  float SIGoodHitZ;
  float SIGoodHitZ90;
  float SIID;
  float SIPhi;
  float SID0;
  float SIPt;
  float SIZ;
  float SIZsig;
  float SID0sig;
  float SICot;
  float SIChis;
  float SITotHitX;         
  float SITotHitZ;        
  float SITotHitZ90; 
  
  // The error matrix
  float ErrCotCot;
  float ErrCotCrv;
  float ErrCotZ0;
  float ErrCotD0;
  float ErrCotPhi0;

  float ErrCrvCrv;
  float ErrCrvZ0;
  float ErrCrvD0;
  float ErrCrvPhi0;

  float ErrZ0Z0;
  float ErrZ0D0;
  float ErrZ0Phi0;

  float ErrD0D0;
  float ErrD0Phi0;

  float ErrPhi0Phi0;          

  ClassDef(offltrack,2) 
};


//----------------------------------
// Cot Hit
//----------------------------------
class cothit : public TObject {
  public:
  
  cothit();
  ~cothit() {};
 
  int Layer;
  int Cell;
  int Wire;
  int Start;
  int Width;

  ClassDef(cothit,1) 
};


//----------------------------------
// XFT Hit
//----------------------------------
class xfthit : public TObject {
  public:
  
  xfthit();
  ~xfthit() {};

  int Prompt;
  int Delayed;
  int Sl;
  int AbsCell;
  int LocalCell;
  int Crate;
  int Board;
  int Chip;
  
  ClassDef(xfthit,1) 
};

 
//----------------------------------
// XFT Pixel
//----------------------------------
class xftpixel : public TObject {
  public:
  
  xftpixel();
  ~xftpixel() {};

  int Sl;
  int AbsPix;
  int Board;
  int Crate;
  int Chip;
  int LocalPix;
  int LocalCell;
  
  ClassDef(xftpixel,1) 
};

  
//----------------------------------
// XFT Track
//----------------------------------
class xfttrack : public TObject {
  public:
  
  xfttrack();
  ~xfttrack() {};

  int ptBin;
  int miniPhi;
  int shortBit;
  int isolationBit;
  int linkerChip;
  int linkerBoard;
  int linkerCrate;
  double absPhi;
  double ptVal; 
  
  ClassDef(xfttrack,1) 
};



//---------------------------------- 
// SecVtxTrack<-->Jet Association
//----------------------------------
class tjassoc : public TObject {
  public:
  
  tjassoc();
  ~tjassoc() {};

  short int jetid;
  short int trkid;
  short int acode;
  
  ClassDef(tjassoc,1) 
};


//---------------------------------- 
// JetProbTrack<-->Jet Association
//----------------------------------
class jetprobTJassoc : public TObject {
  public:
  
  jetprobTJassoc();
  ~jetprobTJassoc() {};

  short int jetid;
  short int trkid;
  
  ClassDef(jetprobTJassoc,1) 
};


//----------------------------------
// Top Mass Fit
//----------------------------------
class topFit : public TObject {
  public:

  topFit();
  ~topFit() {};

  float Chi2;
  float Mass;
  float ErrPa;
  float ErrPl;
  float ErrMi;
  // ***NEW***
  int config;
  int tagok;
  float jettheta[4];
  float jetphi[4];
  float jetptraw[4];
  float jetptgeneric[4];
  float jetptgg[4];
  float jetsigma[4];
  float jetptout[4];
  // ***END***

  ClassDef(topFit,2)
};