#ifndef PHOENIX_HH
#define PHOENIX_HH

//Blocks: phoenix

#include "myelectron_t.hh"
// definition of "fidword" variable:
// "fidword" is a bitmap, where the following bits are set:
// FOR CENTRAL:
// bit 0 = |xces| < 21
// bit 1 = |zces| > 9
// bit 2 = |zces| < 217
// bit 3 = |zces| > 14
// bit 4 = not in chimney [defined as .82 < eta < 1.1, 5pi/12 < phi < pi/2
// FOR PLUG:
// bit 16 = |deteta| > 1.2
// bit 17 = |deteta| < 2.11
// bit 18 = |deteta| < 2.5

struct myphoenix_t {
  // The nutple runs the PhoenixTracking, SiPatternRecModule-PhoEle, and
  //  PhoenixElectrons modules which create a Phoenix specific collection of 
  // EmObjects and associated tracks. 

  // The Phoenix block loops over these Phoenix EmObjects, matches them to 
  // standard EmObjects in the Electron block and then stores important 
  // track information. 
  
  // It should be noted that the Phoenix EmObjects are not in 1-1 
  // correspondence with the standard EmObjects in the Electron block. 
  // At the moment, I do not know the difference between the two collections, 
  // but the Phoenix EmObjects seem to be a subset of the standard EmObjects.
  // The rational for what's missing isn't clear -- they can be both central
  // and plug EmObjects with and without associated DefTracks.

  // However, the Phoenix EmObject collection contains both plug and central 
  // EmObjects, so you can use the Phoenix Block to find electrons in both 
  // the Central and Plug regions (but you might miss some things). 

  // My best understanding is that you only use Phoenix electrons with 
  // Phoenix tracks, otherwise you should get the emObject from the 
  // Electron or Photon block.

  Int_t nphoenix;
  // Number of phoenix objects in the event

  Int_t trkindex[MAXELE]; //[nphoenix]
  // This is the Track index of the best matching _DEFTRACK_ in the track 
  // block as matched by track ID. It is _NOT_ a Phoenix track. We do not 
  // store Phoenix tracks in the Track block.

  Int_t tracktyp[MAXELE]; //[nphoenix]
  // This is the type of track found:
  // tracktyp==0 means it's a Phoenix track.
  // tracktyp==1 means it's a defTrack.
  // tracktyp < 0 means no track could be found.

  // More specifically:
  // If there is a Phoenix track associated with the EmObject, tracktyp==0.
  // If there is no Phoenix track, but there is a DefTrack, tracktyp==1.
  // If there's neither a Phoenix nor a Def track associated, tracktyp==-1.

  Int_t eleindex[MAXELE]; //[nphoenix]
  // This is the ele index of the phoenix electron. It's found by tightly 
  // matching et and delta r (both must be less than 1E-5) with an object
  // from defEmObjects.

  // The following code comes straight from the track block. These were a few
  // of the track variables I thought might be useful in case a track match
  // could not be found between a phoenix track and the track block. 
  // Regardless, you should look at the track block to figure out exactly
  // what these do (variable names are the same).

  // NB: If a Phoenix track is found, then these values are computed using
  // the Phoenix track, and might not correspond to the deftrack values found
  // in the track block. 

  Int_t svxhits[MAXELE];     //[nphoenix] 
  // Number of hits in SVX

  Int_t vertex[MAXELE];      //[nphoenix]
                             // Index of associated vertex in vertex
                             // block (not filled yet)
  
  Float_t d0[MAXELE]; //[nphoenix]
  Float_t x0[MAXELE]; //[nphoenix]
  Float_t y0[MAXELE]; //[nphoenix]
  Float_t z0[MAXELE]; //[nphoenix]
  Float_t trkchi2[MAXELE]; //[nphoenix]

  Float_t t0[MAXELE];       //[nphoenix] t0 of track (not filled yet)

  Float_t cord0[MAXELE]; //[nphoenix]
  Int_t dof[MAXELE]; //[nphoenix] degrees of freedom for the track fit

  Int_t trkid[MAXELE]; //[nphoenix] Track ID # 
  Int_t hitpattern[MAXELE]; //[nphoenix]
  Int_t errorlayers[MAXELE]; //[nphoenix]
  Int_t integlayers[MAXELE]; //[nphoenix]

  Int_t alg[MAXELE]; //[nphoenix]
  Float_t covMtx[MAXELE][15]; //[nphoenix][15]

  Float_t p[MAXELE]; //[nphoenix]
  Float_t px[MAXELE]; //[nphoenix]
  Float_t py[MAXELE]; //[nphoenix]
  Float_t pz[MAXELE]; //[nphoenix]
  Float_t pt[MAXELE]; //[nphoenix]
  Float_t eta[MAXELE]; //[nphoenix]
  Float_t phi0[MAXELE]; //[nphoenix]

  Float_t charge[MAXELE]; //[nphoenix]
};

#endif