#ifdef __GNUG__
#pragma implementation
#endif

#include "Stntuple/obj/TStnTrack.hh"
#include "Stntuple/obj/TStnVertex.hh"

ClassImp(TStnVertex)

//------------------------------------------------------------------------------
TStnVertex::TStnVertex(Int_t Number) 
    :  fVClass(0),fQ(0),fNTracks(0),fNumber(Number),
       fMassError(0),fChi2(0),fNdof(0),
       fSumW(0),fSumW2(0),fSumZ(0),fSumZ2(0),
       fSumX(0),fSumX2(0),fSumY(0),fSumY2(0), fT0(0), fT0Error(0)
{
  // default constructor
}

//------------------------------------------------------------------------------
TStnVertex::~TStnVertex() {
  // destructor
//    fVtxCov.Invalidate();
//    fMomCov.Invalidate();
}

//_____________________________________________________________________________
int TStnVertex::Init(TStnTrack* track) 
{
  fSumX      = track->X0();
  fSumY      = track->Y0();
  fSumZ      = track->Z0();
  fVertex.SetXYZ(fSumX,fSumY,fSumZ);
  fSumW      = 1.;
  fQ         = track->Charge();
  fNTracks   = 1;
  fT0        = 0;
  fT0Error   = 0;

  return 0;
}

//_____________________________________________________________________________
int TStnVertex::Add(TStnTrack* track) 
{
  // temporarily forget about the track error matrix... shame on me...
  fSumX      += track->X0();
  fSumY      += track->Y0();
  fSumZ      += track->Z0();
  fSumW      += 1.;
  fVertex.SetXYZ(fSumX/fSumW,fSumY/fSumW,fSumZ/fSumW);
  fQ         += track->Charge();
  fNTracks   += 1;
  fMomentum  += *(track->Momentum());
  return 0;
}

//_____________________________________________________________________________
Int_t TStnVertex::Compare(const TObject* vertex) const
{
  // compare 2 vertices based on the number of associated tracks

  int dn = fNTracks - ((TStnVertex*) vertex)->NTracks();

  if      (dn < 0) return  1;
  else if (dn > 0) return -1;
  else             return  0;
}

//_____________________________________________________________________________
void TStnVertex::ReadV1(TBuffer& R__b) {
  struct TStnVertexV1_t {
    Int_t          fVClass;		// vertex class
    TVector3       fVertex;		// position of the vertex
    TLorentzVector fMomentum;		// reconstructed momentum
    Float_t        fQ;			// total track charge in the vertex
    Short_t        fNumber;		// sequential number of this vertex
    Short_t        fNTracks;		// N(tracks) assoc. with the vertex
    TMatrix33      fVtxCov;		// || vertex covariance 
    TMatrix33      fMomCov;		// || 3-momentum covariance
    
    Float_t        fMassError;		// mass error
    Float_t        fChi2;		// chi2 of fit
    Float_t        fNdof;	        // number of degrees of freedom of fit
  } v;

  TObject::Streamer(R__b);
  R__b >> fVClass;
  fVertex.Streamer(R__b);
  fMomentum.Streamer(R__b);
  R__b >> fQ;
  R__b >> fNumber;
  R__b >> fNTracks;
  fVtxCov.Streamer(R__b);
  fMomCov.Streamer(R__b);
  R__b >> fMassError;
  R__b >> fChi2;
  R__b >> fNdof;
//-----------------------------------------------------------------------------
//  added in V2
//-----------------------------------------------------------------------------
  fSumPt   = 0.0;
//-----------------------------------------------------------------------------
//  added in V3
//-----------------------------------------------------------------------------
  fT0      = 0.;
  fT0Error = 0.;
}

//_____________________________________________________________________________
void TStnVertex::ReadV2(TBuffer& R__b) {
  // read version 2 of the vertex, sequence of the data members determines
  // the order of reading

  struct TStnVertexV1_t {
    Int_t          fVClass;		// vertex class
    TVector3       fVertex;		// position of the vertex
    TLorentzVector fMomentum;		// reconstructed momentum
    Float_t        fQ;			// total track charge in the vertex
    Short_t        fNumber;		// sequential number of this vertex
    Short_t        fNTracks;		// N(tracks) assoc. with the vertex
    TMatrix33      fVtxCov;		// || vertex covariance 
    TMatrix33      fMomCov;		// || 3-momentum covariance
    
    Float_t        fMassError;		// mass error
    Float_t        fChi2;		// chi2 of fit
    Float_t        fNdof;	        // number of degrees of freedom of fit
    Float_t        fSumPt;		// scalar total pt of tracks in vertex, new in V2
  } v;

  TObject::Streamer(R__b);
  R__b >> fVClass;
  fVertex.Streamer(R__b);
  fMomentum.Streamer(R__b);
  R__b >> fQ;
  R__b >> fNumber;
  R__b >> fNTracks;
  fVtxCov.Streamer(R__b);
  fMomCov.Streamer(R__b);
  R__b >> fMassError;
  R__b >> fChi2;
  R__b >> fNdof;
//-----------------------------------------------------------------------------
//  added in V2
//-----------------------------------------------------------------------------
  R__b >> fSumPt;
//-----------------------------------------------------------------------------
//  added in V3
//-----------------------------------------------------------------------------
  fT0      = 0.;
  fT0Error = 0.;
}

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

  UInt_t R__s, R__c;

  int nws = ((Short_t*) &fVClass) - &fNumber;
  int nwi = ((Int_t*  ) &fQ     ) - &fVClass;
  int nwf = ((Float_t*) &fVertex) - &fQ;

  if (R__b.IsReading()) {
    Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
    
    if      (R__v == 3) {
      TObject::Streamer(R__b);

      R__b.ReadFastArray(&fNumber,nws);
      R__b.ReadFastArray(&fVClass,nwi);
      R__b.ReadFastArray(&fQ     ,nwf);

      fVertex.Streamer(R__b);
      fMomentum.Streamer(R__b);
      fVtxCov.Streamer(R__b);
      fMomCov.Streamer(R__b);
    }
    else if (R__v == 2) ReadV2(R__b);
    else if (R__v == 1) ReadV1(R__b);

    R__b.CheckByteCount(R__s, R__c, TStnVertex::IsA());
  } 
  else {
    R__c = R__b.WriteVersion(TStnVertex::IsA(), kTRUE);
    TObject::Streamer(R__b);

    R__b.WriteFastArray(&fNumber,nws);
    R__b.WriteFastArray(&fVClass,nwi);
    R__b.WriteFastArray(&fQ     ,nwf);

    fVertex.Streamer(R__b);
    fMomentum.Streamer(R__b);
    fVtxCov.Streamer(R__b);
    fMomCov.Streamer(R__b);

    R__b.SetByteCount(R__c, kTRUE);
  }
}


//_____________________________________________________________________________
void TStnVertex::Print(const char* Opt) const {
  if (strstr(Opt,"banner") || (strcmp(Opt,"") == 0)) {
    printf(" i Class N(tracks)  X        Y            Z   SumPt(mom)  SumPt    SumQ\n");
  }

  if (strstr(Opt,"data") || (strcmp(Opt,"") == 0)) {
    printf(" %3i %3i %3i %10.4f %10.4f %10.4f  %10.3f %10.3f %3.0f %6.2f\n",
	   fNumber,
	   fVClass,
	   fNTracks,
	   fVertex.X(),
	   fVertex.Y(),
	   fVertex.Z(),
	   fMomentum.Pt(),
	   fSumPt,
	   fQ,
	   fT0);
  }
}