#ifndef JETSTRUCT_HH
#define JETSTRUCT_HH

//Blocks: jet,jet2,jet3

const Int_t MAXJET=50;
const Int_t MAXJETCOLLNAMELEN=24;

struct myjet_t {

  // Add description of jet variables
  // Stephen Levy
  // October 2, 2003
  //
  // Note: We store information for three different user specified jet
  // collections, which are currently
  //   1) Jets made by JetCluModule in an r-phi cone of 0.4
  //   2) Jets made by JetCluModule in an r-phi cone of 0.7
  //   3) Jets originally made by JetCluModule in an r-phi cone of 0.4
  //      that are reclustered by TopEventModule (TopEM).  In the
  //      reclustering, TopEM uses a new zVertex position (currently
  //      determined by the ZVertexColl vertex with quality>=12
  //      closest to the z0 of a tight lepton, though this is tcl
  //      changeable), offline LER corrections, and removes the towers
  //      matched to tight electron candidates.
  // However, the jet collections can be changed by tcl so they might
  // not still correspond to those listed above.
  //
  // To further confuse matters, the UCNtuple (UCNT) finds its own
  // primary vertex for the event and some of the jet variables are
  // calculated after this vertex has been determined.  To be clear,
  // each variable will be labelled BPV (before primary vertex) or APV
  // (after primary vertex) to identify when it was calculated.
  //
  // To make matters worse, none of the variable calculated after the
  // UCNT has found the primary vertex depend on this vertex!!!!!!!
  // This makes the above APV/BPV distinction meaningless.  NB: I
  // didn't discover this until I had finished documenting all the
  // variables.

  Int_t njet; // BPV
  // Number of jets in the event

  Int_t ntrks[MAXJET]; //[njet] APV
  // Number of tracks matched to the jet according to the following algorithm:
  //  Loop over all the tracks in CdfTrackView::defTracks, testing each one as follows:
  //  (1) Let the jet's centroidEta, centroidPhi (from CdfJet) be phi_jet, eta_jet
  //  (2) Use the track extrapolation code to extrapolate to r = r_ces,
  //      where r_ces is stored in CalorGeometry/CalParameters.hh as TLYCES (add a
  //      small correction to get to the shower location.) Check whether this is
  //      central:
  //      (A) If |z| < z_plug, use r = r_ces, eta, phi at this location
  //      (B) If |z| > z_plug, use eta, phi at z = z_plug (TLZPEM plus
  //          correction) (i.e., we went too far so we re-extrapolate to z_plug).
  //  (3) If (eta_track - eta_jet)^2 + (phi_track - phi_jet)^2 < JetConeSize^2
  //      count the track as in the jet.
  //  The choice of r_ces is somewhat arbitrary.
  //
  //  Note: when this parameter is determined, we also return the
  //  collection of tracks that have been associated to this jet.  It
  //  is this collection of tracks that is used in the calculations of
  //  many following variables.  The description of the variable
  //  should make it clear whether these tracks were used in its
  //  calculation.

  Int_t ntrkippos[MAXJET]; //[njet] APV
  // Number of tracks in the jet with positive impact parameter, where
  // positive impact parameter means that the dot product of the
  // transverse jet momentum with the vector pointing to the track's
  // (x0,y0) position is positive.
  // The tracks associated with the jet are found according to the
  // method listed above in ntrks.

  Int_t ntrklzpos[MAXJET]; //[njet] APV
  // Number of tracks in the jet with positive angular momentum about
  // the z-axis.
  // The tracks associated with the jet are found according to the
  // method listed above in ntrks.

  Int_t nsecvtxtrk[MAXJET]; //[njet] APV
  // Number of tracks we have associated with this jet that are also
  // in the track collection "SecVtxTracks" made by SecVtxModule.
  // Tracks are in "SecVtxTracks" if they are defTracks that pass some
  // tcl defined pt cut, have quality==1, and are not Silicon only.
  // This does not mean that SecVtxMod has associated these tracks to
  // this jet.
  // The tracks we associated with the jet are found according to the
  // method listed above in ntrks.
  //
  // The usefulness of this variable is unclear to me.

  Int_t word[MAXJET]; //[njet] APV
  // Returns 1 if phi of CdfMetObject is within the jet.coneRadius()
  // of the jet phi.  Otherwise returns 0.

  Float_t px[MAXJET];       //[njet] BPV
  Float_t py[MAXJET];       //[njet] BPV
  Float_t pz[MAXJET];       //[njet] BPV
  Float_t e[MAXJET];        //[njet] BPV
  // Jet four momentum for all jet algorithms (JetClu, MidPoint,
  // KtClus) is found by the FourVectorSummer class.  See
  //   http://cdfcodebrowser.fnal.gov/CdfCode/source/Calor/doc/CalorDoc.html
  // and CDF Note 5293 for the real details.  They are somewhat
  // complicated but...
  //   The main point is that there are two distinct stages to forming
  //   a jet.  In the "selection" stage the algorithm chooses
  //   calorimeter towers near each other.  In the "recombination"
  //   scheme the energy in the towers is combined to form the four
  //   momentum of the jet.  The kinematic variables used in the
  //   selection stage to find the jet do not need to be the same as
  //   those used to characterize the momentum of the jet.  The JetClu
  //   (cone algorithm) _selection_ is done by the "SnowMassSummer"
  //   class based on scalar Et weighted centroids (in fact this is a
  //   recombination scheme that is also used for selection).
  //   Currently, we the _recombination_ scheme is done by the
  //   "FourVectorSummer" class.
  //

  Float_t et[MAXJET];       //[njet] BPV
  // Transverse energy calculated from p4 = jet.e() * sinTheta

  Float_t eta[MAXJET];      //[njet] BPV
  // eta = 0.5 * ln( totP + pz / totP - pz)

  Float_t phi[MAXJET];      //[njet] BPV
  // arctan( py / px)

  Float_t pt[MAXJET];       //[njet] BPV
  // sqrt(px^2 + py^2)

  Float_t mass[MAXJET];     //[njet] BPV
  // jet mass

  Float_t deteta[MAXJET];   //[njet] BPV
  // Return the pseudorapidity calculated from the vertex z = 0.0
  // using always the SnowMassSummer class (see 4-mom description above).

  Float_t emfr[MAXJET];     //[njet] BPV
  // Return sum of emEnergy of the towers of the jet divided by totE of the jet.

  Float_t chargefr[MAXJET]; //[njet] APV
  // Return the sum of pt of all tracks in the cone of the jet divided
  // by pt of the jet.
  // The tracks associated with the jet are found according to the
  // method listed above in ntrks.

  Float_t ep[MAXJET];       //[njet] APV
  // Inverse of chargefr (above).  Why do we store this?

  Float_t eguard[MAXJET];   //[njet] BPV
  // Return the sum of energy in the guard towers (towers near the
  // edge of the plug and towers bordering 30 and 90 degrees cracks).

  Float_t corfm[MAXJET];    //[njet] BPV
  // Jet energy correction consisting of:
  //   1. Relative Energy Corrections (Make response uniform in eta) 
  //   2. Time Dependence Corrections 
  //   3. Raw Energy Scale corrections (Go back to Run Raw scale) 
  //   4. Multiple Interaction corrections 
  //   5. Absolute Energy corrections (From calorimeter energy to particle energy) 
  //   6. Underlying energy corrections 
  //   7. Out of cone corrections (From particle level-jet to parton energy) 
  // The corrections are described in greater detail on this web-page:
  //   http://www-cdf.fnal.gov/internal/people/links/AnwarBhatti/RunIIJetCorrections.html

  Float_t corfd[MAXJET];    //[njet] BPV
  // Jet energy correction consisting of corrections 1-5 listed above.

  Float_t zvtx[MAXJET];     //[njet] APV
  // The weighted z0 average of the tracks in the jet.
  // The tracks associated with the jet are found according to the
  // method listed above in ntrks.

  Float_t dz[MAXJET];       //[njet] APV
  // The error on the weighted z0 average of the tracks in the jet.
  // The tracks associated with the jet are found according to the
  // method listed above in ntrks.

  Float_t sumtrkpt[MAXJET]; //[njet] APV
  // Sum pt of tracks in the jet.
  // The tracks associated with the jet are found according to the
  // method listed above in ntrks.

  Float_t etaeta[MAXJET];   //[njet] BPV
  // Gives a measure of the energy distribution of the jets in eta.

  Float_t etaphi[MAXJET];   //[njet] BPV
  // Gives a measure of the energy distribution of the jets in eta-phi.

  Float_t phiphi[MAXJET];   //[njet] BPV
  // Gives a measure of the energy distribution of the jets in eta.

  // For the variables, vpt, vtxindex, voccupancy, vfracoccupancy,
  // vtxz that follow we call the function JetVariables::jetVtxStats.
  // We supply this function with our jet, its associated tracks, a
  // list of "VertexColl" vertices and one of the vertices in this
  // list.  The function sees if the track z0 is within 5cm of the
  // given vertex z position and also checks that the track z0 is not
  // closer to another z vertex in the collection.  The function
  // returns the number of tracks fulfilling these requirements, the
  // summed pt of these tracks, and the summed pt divided by the
  // number of tracks.  If no tracks satisfy the conditions, zero is
  // returned for all values.
  //
  // We keep track of the vertex associated with the maximum summed
  // pt, maximum number of tracks, and the one closest to the jet z
  // vertex (zvtx) described above.  The second array index on the
  // variable indicates which criteria it has satisfied:
  //   [0] = max summed pt
  //   [1] = max number of tracks
  //   [2] = closest to jet z vertex

  Float_t vpt[MAXJET][3];   //[njet][3] APV
  // Summed pt of tracks described above for the vertex

  Float_t novpt[MAXJET];   //[njet] APV
  // Summed pt of tracks in the jet whose z vertex is not within 5cm
  // of the any vertex in the list of "VertexColl" vertices.  The
  // vertex be of the type Vertex::Primary to be considered.
  // Note : the function calls JetVariables2::jetNoVPt which says that
  // the provided vertex list should be from VxPrim.  However we are
  // currently providing a list made by ZVertexMod.

  Int_t vtxindex[MAXJET][3]; //[njet][3] APV
  // Index of "VertexColl" vertex

  Int_t voccupancy[MAXJET][3];        //[njet][3] APV
  // Number of tracks in the vertex

  Float_t vfracoccupancy[MAXJET][3];  //[njet][3] APV
  // Summed pt divided by the number of tracks in the vertex

  Float_t vtxz[MAXJET][3];            //[njet][3] APV
  // z position of the vertex

  Char_t jetcoll[MAXJETCOLLNAMELEN];  // BPV
  // name of jet collection

};

#endif