#ifdef CDF1
#include <inc/bcs.h>
#include <types/TauoTypes.hh>
#include <Bbos/TYbosBank.hh>
#include <inc/taufnd.hh>
#include <run1cpp/bnk/ttrs_bank.hh>
#include <run1cpp/bnk/GenpParticle.hh>
#include <run1cpp/tau/TTau.hh>
#endif

#include "Stntuple/obj/TStnDataBlock.hh"
#include "Stntuple/obj/TStnElectron.hh"
#include "Stntuple/obj/TStnMuon.hh"
#include "Stntuple/obj/TStnTau.hh"

ClassImp(TStnTau)

//______________________________________________________________________________

void TStnTau::ReadV2(TBuffer &R__b) 
{
  // read version 2 of TStnTau: make sure that any changes in the types 
  // of the data members won't affect the I/O - read the data into EXACTLY
  // the buffer of version 2 structure. Also assume that v1 is gone long ago

  struct TStnTauV2_t {
    Int_t          fDecayMode;
    Int_t          fNumber;
    TLorentzVector fTrackMomentum;
    TLorentzVector fClusterMomentum;
    TLorentzVector fGenpMomentum;		// ! generated 4-momentum
    Float_t        fDteta;
    Float_t        fZv;
    Float_t        fMass;
    Float_t        fPtvis;
    Float_t        fStatusCode;
    Float_t        fDelr;
    Float_t        fEtaEta;		// eta-eta moment of the cal cluster
    Float_t        fPhiPhi;		// phi-phi moment of the cal cluster
    
    Float_t        fEtEm;
    Float_t        fEtHad;
    Float_t        fEmfr;
    
    Int_t          fMustub;
    Int_t          fMuhits;

//  vector<int>    fTrind;              // ! track indices - don't write out
					// as it wouldn't allow to store tau's
					// in TClonesArray

					// information about the charged tracks 
					// and towers
    Int_t          fNTracks;
    Int_t          fNTracks10;		// Ntracks in 10deg cone around the cluster
    Int_t          fNTracks30;		// Ntracks in 30deg cone
    Int_t          fNWrongTracks;		// # tracks from the wrong vertex
    Int_t          fNExtrapTracks;	// 
    Int_t          fNExtrapTracks10;
    Int_t          fNExtrapTracks30;

    short          fClslNumber;		// # of the corresponding CLSL bank
    short          fJetsNumber;		// # of the corresponding JETS bank
    short          fTauoNumber;		// # of the TAUO bank (Run I)
    Int_t          fNL2Towers;		// N(L2-like towers) in the cluster
    Int_t          fNTowers;		// N(TOWE towers) in the cluster
    Float_t        fTowerEt[2];	        // Et of the 2 highest towers
					// this is reconstructed
    Int_t          fNPi0;
    TClonesArray*  fPi0List;		// ! do not write it out

    Float_t        fSumPt10;		// sum(Pt) 10deg cone around the clust
    Float_t        fSumPt30;		// sum(Pt) in 10-30 annulus

    Float_t        fSeedTrackZ;		// Z(vertex) of the seed track
    Float_t        fSeedTrackPt;	// Pt of the stiffest daughter track
    Float_t        fSeedDeltaPhi;	// delta(phi) cluster-seed track
    Float_t        fSumTrackP;		// sum trk cluster momenta (not Pt's!)
    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)

    Float_t        fCalIso04;		// calorimetry isolation in cone 0.4
					// version 2: added
    Int_t          fNTrkTau;            // N(tracks) for the cluster M < M_tau
    Float_t        fIsoTau;             // isolation of the tau cluster
  } tau;
//-----------------------------------------------------------------------------
//  read the data
//-----------------------------------------------------------------------------
  TStnLepton::Streamer(R__b);
  R__b >> tau.fDecayMode;
  R__b >> tau.fNumber;
  tau.fTrackMomentum.Streamer(R__b);
  tau.fClusterMomentum.Streamer(R__b);
  R__b >> tau.fDteta;
  R__b >> tau.fZv;
  R__b >> tau.fMass;
  R__b >> tau.fPtvis;
  R__b >> tau.fStatusCode;
  R__b >> tau.fDelr;
  R__b >> tau.fEtaEta;
  R__b >> tau.fPhiPhi;
  R__b >> tau.fEtEm;
  R__b >> tau.fEtHad;
  R__b >> tau.fEmfr;
  R__b >> tau.fMustub;
  R__b >> tau.fMuhits;
  R__b >> tau.fNTracks;
  R__b >> tau.fNTracks10;
  R__b >> tau.fNTracks30;
  R__b >> tau.fNWrongTracks;
  R__b >> tau.fNExtrapTracks;
  R__b >> tau.fNExtrapTracks10;
  R__b >> tau.fNExtrapTracks30;
  R__b >> tau.fClslNumber;
  R__b >> tau.fJetsNumber;
  R__b >> tau.fTauoNumber;
  R__b >> tau.fNL2Towers;
  R__b >> tau.fNTowers;
  R__b.ReadStaticArray(tau.fTowerEt);
  R__b >> tau.fNPi0;
  R__b >> tau.fSumPt10;
  R__b >> tau.fSumPt30;
  R__b >> tau.fSeedTrackZ;
  R__b >> tau.fSeedTrackPt;
  R__b >> tau.fSeedDeltaPhi;
  R__b >> tau.fSumTrackP;
  R__b >> tau.fTrackEta;
  R__b >> tau.fTrackPhi;
  R__b >> tau.fTrackMass;
  R__b >> tau.fMet;
  R__b >> tau.fCalIso04;
  R__b >> tau.fNTrkTau;
  R__b >> tau.fIsoTau;
//-----------------------------------------------------------------------------
//  now copy the data into the current tau record in the most safe way possible
//-----------------------------------------------------------------------------
  fDecayMode       = tau.fDecayMode;
  fNumber          = tau.fNumber;
  fTrackMomentum   = tau.fTrackMomentum;
  fClusterMomentum = tau.fClusterMomentum;
  fDteta           = tau.fDteta;
  fZv              = tau.fZv;
  //  fMass            = tau.fMass;
  //  fPtvis           = tau.fPtvis;
  fStatusCode      = tau.fStatusCode;
  fDelr            = tau.fDelr;
  fEtaEta          = tau.fEtaEta;
  fPhiPhi          = tau.fPhiPhi;
  fEtEm            = tau.fEtEm;
  fEtHad           = tau.fEtHad;
  fEmfr            = tau.fEmfr;
  fNMuStubs        = tau.fMustub;
  fNMuHits         = tau.fMuhits;
  fNTracks         = tau.fNTracks;
  fNTracks10       = tau.fNTracks10;
  fNTracks30       = tau.fNTracks30;
  fNWrongTracks    = tau.fNWrongTracks;
  fNExtrapTracks   = tau.fNExtrapTracks;
  fNExtrapTracks10 = tau.fNExtrapTracks10;
  fNExtrapTracks30 = tau.fNExtrapTracks30;
  fClslNumber      = tau.fClslNumber;
  fJetsNumber      = tau.fJetsNumber;
  fTauoNumber      = tau.fTauoNumber;
  fNL2Towers       = tau.fNL2Towers;
  fNTowers         = tau.fNTowers;
  fTowerEt[0]      = tau.fTowerEt[0];
  fTowerEt[1]      = tau.fTowerEt[1];
  fNPi0            = tau.fNPi0;
  fSumPt10         = tau.fSumPt10;
  fSumPt30         = tau.fSumPt30;
  fSeedTrackZ      = tau.fSeedTrackZ;
  fSeedTrackPt     = tau.fSeedTrackPt;
  fSeedDeltaPhi    = tau.fSeedDeltaPhi;
  fSumTrackP       = tau.fSumTrackP;
  //  fTrackEta        = tau.fTrackEta;
  //  fTrackPhi        = tau.fTrackPhi;
  //  fTrackMass       = tau.fTrackMass;
  //  fMet             = tau.fMet;
  fCalIso04        = tau.fCalIso04;
  fNTrkTau         = tau.fNTrkTau;
  fTrackIso        = tau.fIsoTau;
}

//______________________________________________________________________________

void TStnTau::ReadV3(TBuffer &R__b) 
{
  struct TStnTauV3_t {
    Short_t        fDecayMode;
    Short_t        fNumber;
    Short_t        fNTracks;              // for Run I
    Short_t        fNTracks10;            // Ntrk(10deg cone around the cluster)

    Short_t        fNTracks30;            // Ntracks in 30deg cone
    Short_t        fNWrongTracks;         // # tracks from the wrong vertex
    Short_t        fNExtrapTracks;        // 
    Short_t        fNExtrapTracks10;
    Short_t        fNExtrapTracks30;
    
    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
    Short_t        fNTowers;              // N(cal towers) in the cluster
    Short_t        fNPi0;                 // # of pi0's
    Short_t        fNTrkTau;              // N(tracks) for the cluster M < M_tau

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

    Float_t        fStatusCode;
    Float_t        fDteta;
    Float_t        fZv;
    Float_t        fDelr;
    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
    Float_t        fEtHad;                // cal-only
    Float_t        fEmfr;                 // EM fraction of calor cluster
    Float_t        fTowerEt[2];           // Et of the 2 highest towers
    Float_t        fSumPt10;              // sum(Pt) 10deg cone around the clust
    Float_t        fSumPt30;              // sum(Pt) in 10-30 annulus
    Float_t        fSeedTrackZ;           // Z(vertex) of the seed track
    Float_t        fSeedTrackPt;          // Pt of the stiffest daughter track
    Float_t        fSeedDeltaPhi;         // delta(phi) cluster-seed track
    Float_t        fSumTrackP;            // sum trk cluster momenta (not Pt's!)

    Float_t        fCalIso04;             // calorimetry isolation in cone 0.4
    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 in cone 0.4
    const CdfTau*  fCdfTau;		// ! also marking the end of record
  } tau;
                        		// read the v3 version of tau 
  TStnLepton::Streamer(R__b);
  fClusterMomentum.Streamer(R__b);
  fTrackMomentum.Streamer(R__b);
  fVisMomentum.Streamer(R__b);
  
  int nws = ((Short_t*) &tau.fStatusCode ) - &tau.fDecayMode;
  int nwf = ((Float_t*) &tau.fCdfTau )     - &tau.fStatusCode;

  R__b.ReadFastArray(&tau.fDecayMode,nws);
  R__b.ReadFastArray(&tau.fStatusCode,nwf);

  fDecayMode       = tau.fDecayMode;
  fNumber          = tau.fNumber;
  fNTracks         = tau.fNTracks;
  fNTracks10       = tau.fNTracks10;

  fNTracks30       = tau.fNTracks30;
  fNWrongTracks    = tau.fNWrongTracks;
  fNExtrapTracks   = tau.fNExtrapTracks;
  fNExtrapTracks10 = tau.fNExtrapTracks10;
  fNExtrapTracks30 = tau.fNExtrapTracks30;

  fClslNumber      = tau.fClslNumber;
  fJetsNumber      = tau.fJetsNumber;
  fTauoNumber      = tau.fTauoNumber;

  fNL2Towers       = tau.fNL2Towers;
  fNTowers         = tau.fNTowers;
  fNPi0            = tau.fNPi0;
  fNTrkTau         = tau.fNTrkTau;

  fNMuStubs        = tau.fNMuStubs;
  fNMuHits         = tau.fNMuHits;

  fStatusCode   = tau.fStatusCode;
  fDteta        = tau.fDteta;
  fZv           = tau.fZv;
  fDelr         = tau.fDelr;
  fEtaEta       = tau.fEtaEta;
  fPhiPhi       = tau.fPhiPhi;
  fEtEm         = tau.fEtEm;
  fEtHad        = tau.fEtHad;
  fEmfr         = tau.fEmfr;
  fTowerEt[0]   = tau.fTowerEt[0];
  fTowerEt[1]   = tau.fTowerEt[1];
  fSumPt10      = tau.fSumPt10;
  fSumPt30      = tau.fSumPt30;
  fSeedTrackZ   = tau.fSeedTrackZ;
  fSeedTrackPt  = tau.fSeedTrackPt;
  fSeedDeltaPhi = tau.fSeedDeltaPhi;
  fSumTrackP    = tau.fSumTrackP;

  fCalIso04     = tau.fCalIso04;
  fEmIso04      = tau.fEmIso04;
  fHadIso04     = tau.fHadIso04;
  fTrackIso     = tau.fTrackIso;

//-----------------------------------------------------------------------------
// initialize words undefined/unused in V3
//-----------------------------------------------------------------------------

  fNPi010   = fNPi0;
  fNPi01030 = 0;

  fECorrectionFactor = 1.;
  fTauCone    = TStnDataBlock::kUndefined;
  fTauConePi0 = TStnDataBlock::kUndefined;
  fSumPtPi030 = TStnDataBlock::kUndefined;

//-----------------------------------------------------------------------------
//  make sure that fCdfTau is not defined at that point
//-----------------------------------------------------------------------------

  fCdfTau = NULL;
}

//______________________________________________________________________________
void TStnTau::PostReadV4()
{
  fNTracks = fNTracks30;
  fNPi0 = fNPi010;
  fDelr = sqrt(fEtaEta*fEtaEta + fPhiPhi*fPhiPhi);
  fCalIso04 = fEmIso04 + fHadIso04;
  fZv = fSeedTrackZ;

  // P.Murat: found that v4 doesn't write out/read back fTowerEt[0:1]
  // this forces to set it to 0

  fTowerEt[0] = 0;
  fTowerEt[1] = 0;
}

//______________________________________________________________________________
void TStnTau::Streamer(TBuffer &R__b)
{
   // Stream an object of class TStnTau.

  int nws = ((Short_t*)&fStatusCode) - &fDecayMode;
  int nwf = ((Float_t*)&fCdfTau    ) - &fStatusCode;

  if (R__b.IsReading()) {
    Version_t R__v = R__b.ReadVersion();
    if (R__v <= 2)      ReadV2(R__b);
    else if (R__v == 3) ReadV3(R__b);
    else {
					// read the last (v4) version of tau 
      TStnLepton::Streamer(R__b);
      fClusterMomentum.Streamer(R__b);
      fTrackMomentum.Streamer(R__b);
      fVisMomentum.Streamer(R__b);

      R__b.ReadFastArray(&fDecayMode,nws);
      R__b.ReadFastArray(&fStatusCode,nwf);
      
      PostReadV4();
    }
  } 
  else {
    R__b.WriteVersion(TStnTau::IsA());
    TStnLepton::Streamer(R__b);

    fClusterMomentum.Streamer(R__b);
    fTrackMomentum.Streamer(R__b);
    fVisMomentum.Streamer(R__b);

    R__b.WriteFastArray(&fDecayMode,nws);
    R__b.WriteFastArray(&fStatusCode,nwf);
  }
}

//_____________________________________________________________________________
TStnTau::TStnTau(Int_t Number) {
  fNumber        = Number;
  fSeedTrackPt   = 0;
  fMomentum.SetXYZT(0,0,0,0);
  fTrackMomentum.SetXYZT(0,0,0,0);
  fGenpMomentum.SetXYZT(0,0,0,0);
  fDecayMode     = kHadronicMode;
  fNPi0          = 0;
  fNPi010        = 0;
  fNTracks10     = 0;
  fCharge        = 0.;
  fClslNumber    = -1;
  fJetsNumber    = -1;
  fTauoNumber    = -1;

  fTowerEt[0]    = 0.;
  fTowerEt[1]    = 0.;
  fListOfTracks  = NULL;
  fListOfPi0s    = NULL;

  fStatusCode    = 0;
  fSeedTrack     = NULL;
  fDelXCes       = 1.e6;
  fDelZCes       = 1.e6;
  fSeedTrackXCes = 1.e6;
  fSeedTrackZCes = 1.e6;
  fSeedTrackD0   = 1.e6;
  fZeta          = 1.e6;
}

//_____________________________________________________________________________
TStnTau::TStnTau(TYbosBank* tauo_bank, int i) {
#ifdef CDF1
  // initialize tau starting from the output of Run I FINDTAU module - 
  // TAUO bank number `itauo'. `i' is the sequential number of the tau in
  // the list

  static TYbosBank call;
  static TtrsBank  ttrs;

  TauoRecord_t* tau = (TauoRecord_t*) tauo_bank->data();

  fNumber = i;
  fDecay  = kHadronicDecay;

  TStnLepton::fCharge = tau->fCharge;
  TStnLepton::fMomentum.SetXYZT(tau->fClusterPx,tau->fClusterPy,
				tau->fClusterPz,tau->fClusterE);
  fClusterMomentum.SetXYZT(tau->fClusterPx,tau->fClusterPy,
			   tau->fClusterPz,tau->fClusterE);

				// ****** track momentum is undefined for the 
				// time being


  fZv         = tau->fSeedTrackZ;
  fDteta      = kUndefined;
  fMass       = tau->fTrackMass;
  fPtvis      = kUndefined;
  fStatusCode = kUndefined;
  fEtaEta     = tau->fEtaEta;
  fPhiPhi     = tau->fPhiPhi;
  fDelr       = sqrt(fEtaEta+fPhiPhi);
  fEmfr       = tau->fEmEt/(tau->fEmEt+tau->fHadEt);
  fMustub      = -1;
				// track momentum is undefined for the moment

  fTrackMomentum.SetXYZT(0.,0.,0.,0.);

  fNTracks      = tau->fNTracks;
  fNTracks10    = tau->fNTracks10;
  fNTracks30    = tau->fNTracks30;
  fNWrongTracks = tau->fNWrongTracks;

  fNExtrapTracks   = tau->fNExtrapTracks;
  fNExtrapTracks10 = tau->fNExtrapTracks10;
  fNExtrapTracks30 = tau->fNExtrapTracks30;

  fSumPt10         = tau->fSumPt10;
  fSumPt30         = tau->fSumPt30;

  fTauoNumber      = tauo_bank->number();
  fClslNumber      = tau->fClslNumber;
  fJetsNumber      = tau->fJetsNumber;

  call.Init(gBcs,"CALL",fTauoNumber);

  fNTowers         = call.iw(0);
  fNL2Towers       = tau->fNL2Towers;
  fTowerEt[0]      = tau->fEt[0];
  fTowerEt[1]      = tau->fEt[1];

  fNPi0            = 0;
  fNPi010          = 0;
  fPi0List         = 0;

  fSeedTrackPt  = tau->fSeedTrackPt;
  fSeedTrackZ   = tau->fSeedTrackZ;
  fSeedDeltaPhi = tau->fSeedDeltaPhi;
  fSumTrackP    = tau->fSumTrackP;
  fTrackEta     = tau->fTrackEta;
  fTrackPhi     = tau->fTrackPhi;
  fTrackMass    = tau->fTrackMass;
  fMet          = tau->fMet;
  TTau::Taucaliso(fTauoNumber,0.4,fCalIso04);

  ttrs.Init(fTauoNumber);
  fNTrkTau      = ttrs.NTrkTau();
  fIsoTau       = ttrs.IsoTau();
#endif

  fListOfTracks = NULL;
  fListOfPi0s   = NULL;
  fStatusCode    = 0;
  fSeedTrack     = NULL;
  fDelXCes       = 1.e6;
  fDelZCes       = 1.e6;
  fSeedTrackXCes = 1.e6;
  fSeedTrackZCes = 1.e6;
}

//_____________________________________________________________________________
void TStnTau::InitTransientArrays() {
  if (fListOfTracks == 0) {
    fListOfTracks = new TObjArray();
    fListOfPi0s   = new TObjArray();
  }
}

//_____________________________________________________________________________
void TStnTau::LoopOverDaughters(GENP_PARTICLE* mc) {
#ifdef CDF1
  int i1,i2;
  GENP_PARTICLE d;

  i1 = mc->firstDaughter();
  i2 = i1+mc->nDaughters();

  for (int i=i1; i<i2; i++) {
    d.init(i);

    if (d.nDaughters() <= 1) {
      
      if (! d.isNeutrino()) {
				// calculate momentum of all detectable 
				// daughters

	fMomentum += *d.Momentum();
	fCharge   += d.Charge();
	if (d.Charge() != 0) {
	  fNTracks++;
	  if (fSeedTrackPt < d.Momentum()->Pt()) {
	    fSeedTrackPt = d.Momentum()->Pt();
	  }
	}
      }
      else if (d.isElectron()) {
	fDecay = kElectronDecay;
      }
      else if (d.isMuon()) {
	fDecay = kMuonDecay;
      }
    }
    else {
      this->LoopOverDaughters(&d);
    }
  }
#endif
}

//_____________________________________________________________________________
TStnTau::TStnTau(GENP_PARTICLE* mc) {
#ifdef CDF1
  // all we need is to loop over its daughters and to calculate mass of 
  // everything, which is not a neutrino

  fMomentum.SetXYZT(0.,0.,0.,0.);
  fCharge      = 0;
  fNTracks     = 0;
  fNTracks10   = 0;
  fSeedTrackPt = -1;
  fDecay       = kHadronicDecay;
  fMcNumber    = mc->Number();
  fClslNumber  = -1;
  fJetsNumber  = -1;
  fTauoNumber  = -1;
  
  this->LoopOverDaughters(mc);
#endif
  fListOfTracks = NULL;
  fListOfPi0s   = NULL;
}

//_____________________________________________________________________________
TStnTau::TStnTau(TStnElectron* e) {
  fMomentum    = *e->Momentum();
  fCharge      = e->Charge();
  fDecayMode   = kElectronMode;
  fClslNumber  = -1;
  fJetsNumber  = -1;
  fTauoNumber  = -1;
  fListOfTracks = NULL;
  fListOfPi0s   = NULL;
}

//_____________________________________________________________________________
TStnTau::TStnTau(TStnMuon* mu) {
  fMomentum    = *mu->Momentum();
  fCharge      = mu->Charge();
  fDecayMode   = kMuonMode;
  fClslNumber  = -1;
  fJetsNumber  = -1;
  fTauoNumber  = -1;
  fListOfTracks = NULL;
  fListOfPi0s   = NULL;
}

//_____________________________________________________________________________
void TStnTau::InitFromTaucommon(int itau) {
  // interface to Run I code: define parameters of the tau-candidate 
  // using /TAUCOMMON/
#ifdef CDF1
  fMomentum.SetXYZT(gTaucommon->TAU_EX[itau],
		    gTaucommon->TAU_EY[itau],
		    gTaucommon->TAU_EZ[itau],
		    gTaucommon->TAU_E [itau]);
  
  fCharge     = gTaucommon->TAU_CHRG[itau]; // 10 deg cone...
  fZv         = gTaucommon->TAU_ZVX[ itau];
  fMass       = gTaucommon->TAU_MASS [itau]; // 10 deg cone, includes pi0's
  fNTowers    = gTaucommon->TAU_NTOW [itau];
  fNTracks    = gTaucommon->TAU_NTR04[itau];
  fNTracks10  = gTaucommon->TAU_NTR10[itau];
  fNTracks30  = gTaucommon->TAU_NISO [itau];


  fNExtrapTracks   = gTaucommon->TAU_NTEX04[itau];
  fNExtrapTracks10 = gTaucommon->TAU_NT10X [itau];
  fNExtrapTracks30 = gTaucommon->TAU_NISOX [itau];

  fNPi0       = gTaucommon->TAU_NPI0[itau];
  fMustub     = gTaucommon->TAU_MUSTB[itau];
  fMuhits     = gTaucommon->TAU_MUHITS[itau];
  fTauoNumber = gTaucommon->TAUBANK[itau];
  fJetsNumber = gTaucommon->TAU_JETSBN[itau];

  fTowerEt[0] = gTaucommon->TAU_ETSD[itau];
  fTowerEt[1] = gTaucommon->TAU_ETNX[itau];
  fEtEm       = gTaucommon->TAU_ETEM[itau];
  fEtHad      = gTaucommon->TAU_ETHA[itau];
  fEmfr       = fEtEm/(fEtEm+fEtHad);

  fStatusCode = 1000.+gTaucommon->TAU_ET[itau];
  if (gTaucommon->LOOSETAU[itau] == 1) {
    fStatusCode = 2000.+gTaucommon->TAU_ET[itau];
  }
  if (gTaucommon->TIGHTTAU[itau] == 1) {
    fStatusCode = 3000.+gTaucommon->TAU_ET[itau];
    if (gTaucommon->LOOSETAU[itau] == 1) {
					// 'double-tagged' tau
      fStatusCode = 2000.+gTaucommon->TAU_ET[itau];
    }
  }
  
#endif
}

//_____________________________________________________________________________
TStnTau::~TStnTau() {
  if (fListOfTracks) {
    fListOfTracks->Clear();
    fListOfPi0s->Clear();
    delete fListOfTracks;
    delete fListOfPi0s;
  }
}

//_____________________________________________________________________________
void TStnTau::Print(Option_t* option) const {

  if ((strcmp(option,"") == 0) || strstr(option,"banner")) {
				// print banner
    printf("  N   IDWord      px       py       pz        e ");
    printf("      mass NTow NTrk N10 N30 NPi010 Emfr  Z(trk) Mus Muh");
    printf("    Delr   EmIso  HadIso  CalIso\n");
  }

  if ((strcmp(option,"") == 0) || strstr(option,"data")) {
				// print data

    printf("%3i  %08x %8.3f %8.3f %8.3f %8.3f %8.3f %3i  %3i %3i %3i   %3i",
	   Number(),
	   IDWord(),
	   fMomentum.Px(),
	   fMomentum.Py(),
	   fMomentum.Pz(),
	   fMomentum.E(),
	   Mass(),
           NTowers(),
	   NTracks(),
	   NTracks10(),
	   NTracks30(),
	   NPi010());

    printf("%6.3f %7.3f %3i %3i %7.3f %7.2f %7.2f %7.2f\n",
	   Emfr()     ,
	   SeedTrackZ(),
	   NMuStubs(),
	   NMuHits(),
	   Delr(),
	   EmIso04(),
	   HadIso04(),
	   CalIso04());

    printf("              %8.3f %8.3f %8.3f %8.3f %8.3f\n",
	   fTrackMomentum.Px(),
	   fTrackMomentum.Py(),
	   fTrackMomentum.Pz(),
	   fTrackMomentum.E(),
	   TrackMass());

    printf("              %8.3f %8.3f %8.3f %8.3f %8.3f\n",
	   fVisMomentum.Px(),
	   fVisMomentum.Py(),
	   fVisMomentum.Pz(),
	   fVisMomentum.E(),
	   fVisMomentum.M());
    printf(" trISO %8.3f  pi0ISO %8.3f   cone %8.3f  conePi0 %8.3f  corrF %8.3f\n",
	   fSumPt30,
	   fSumPtPi030,
	   fTauCone,
	   fTauConePi0,
	   fECorrectionFactor);
  }
}