///////////////////////////////////////////////////////////////////////////////
//  Apr 22 2001 P.Murat: STNTUPLE description of the conversion pair
//  
// version 3: added conversion ID word
///////////////////////////////////////////////////////////////////////////////
#include "Stntuple/obj/TStnConversion.hh"

ClassImp(TStnConversion)

//_____________________________________________________________________________
void TStnConversion::ReadV1(TBuffer &R__b) {
  // read V1 of TStnConversion

  struct TStnConversionV1_t {
    TObject        fObject;
    TLorentzVector fMomentum;
    TVector3       fVertex;		// vertex position before fit
    Int_t          fTrackNumber[2];	// tracks
    TVector3       fFittedVertex;
    TLorentzVector fFittedTrackMomentum[2];
    Float_t        fSeparation;		// dist in XY before the fit
    Float_t        fDeltaLam;		// delta(cotangent)
    Float_t        fFittedDeltaLam;
    Float_t        fChi2;
    Float_t        fRadius;
    Float_t        fSign;
  } v1;

  TObject::Streamer(R__b);
  fMomentum.Streamer(R__b);
  fVertex.Streamer(R__b);
  R__b.ReadStaticArray(fTrackNumber);
  fFittedVertex.Streamer(R__b);
  int R__i;
  for (R__i = 0; R__i < 2; R__i++)
    fFittedTrackMomentum[R__i].Streamer(R__b);
  R__b >> fSeparation;
  R__b >> fDeltaLam;
  R__b >> fFittedDeltaLam;
  R__b >> fChi2;
  R__b >> fRadius;
  R__b >> fSign;

  fFitStatus   = 0;
  fZSeparation = 0;
  fIDWord      = 0;
}

//_____________________________________________________________________________
void TStnConversion::ReadV2(TBuffer &R__b) {
  // read V2 of TStnConversion - V2 has only IDWord added

  struct TStnConversionV1_t {
    TObject        fObject;
    TLorentzVector fMomentum;
    TVector3       fVertex;		// vertex position before fit
    TVector3       fFittedVertex;
    TLorentzVector fFittedTrackMomentum[2];
					// --------------- integers
    Int_t          fAlgorithm;	        // 
    Int_t          fTrackNumber[2];	// tracks, 0: positive, 1: negative
    Int_t          fFitStatus;		// added in V2
					// --------------- floats
    Float_t        fSeparation;		// dist in XY before the fit
    Float_t        fZSeparation;		// dist in Z  before the fit
    Float_t        fDeltaLam;		// delta(cotangent)
    Float_t        fFittedDeltaLam;
    Float_t        fChi2;
    Float_t        fProb;
    Float_t        fRadius;
    Float_t        fSign;
    Float_t        fMassGamma;
    Float_t        fCosGamma;
    void*          fEOR;			// ! end of record
  } v2;

  int nwi, nwf;

  nwi = ((Int_t*  )&v2.fSeparation) - &v2.fTrackNumber[0];
  nwf = ((Float_t*)&v2.fEOR       ) - &v2.fSeparation;

  TObject::Streamer(R__b);
  fMomentum.Streamer(R__b);
  fVertex.Streamer(R__b);
  fFittedVertex.Streamer(R__b);
  fFittedTrackMomentum[0].Streamer(R__b);
  fFittedTrackMomentum[1].Streamer(R__b);
  
  R__b.ReadFastArray(fTrackNumber,nwi);
  R__b.ReadFastArray(&fSeparation,nwf);

  fIDWord = 0;
}


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

  UInt_t R__s, R__c;
  int nwi, nwf;

  nwi = ((Int_t*  )&fSeparation) - &fTrackNumber[0];
  nwf = ((Float_t*)&fEOR       ) - &fSeparation;

  if (R__b.IsReading()) {
//-----------------------------------------------------------------------------
// read branch
//-----------------------------------------------------------------------------
    Version_t R__v = R__b.ReadVersion(&R__s, &R__c); 
    if (R__v == 1)  ReadV1(R__b);
    if (R__v == 2)  ReadV2(R__b);
    else {
      TObject::Streamer(R__b);
      fMomentum.Streamer(R__b);
      fVertex.Streamer(R__b);
      fFittedVertex.Streamer(R__b);
      fFittedTrackMomentum[0].Streamer(R__b);
      fFittedTrackMomentum[1].Streamer(R__b);

      R__b.ReadFastArray(fTrackNumber,nwi);
      R__b.ReadFastArray(&fSeparation,nwf);
    }
    R__b.CheckByteCount(R__s, R__c, TStnConversion::IsA());
  } 
  else {
//-----------------------------------------------------------------------------
// write branch
//-----------------------------------------------------------------------------
    R__c = R__b.WriteVersion(TStnConversion::IsA(), kTRUE);
    TObject::Streamer(R__b);
    fMomentum.Streamer(R__b);
    fVertex.Streamer(R__b);
    fFittedVertex.Streamer(R__b);
    fFittedTrackMomentum[0].Streamer(R__b);
    fFittedTrackMomentum[1].Streamer(R__b);

    R__b.WriteFastArray(fTrackNumber,nwi);
    R__b.WriteFastArray(&fSeparation,nwf);

    R__b.SetByteCount(R__c, kTRUE);
  }
}

//_____________________________________________________________________________
TStnConversion::TStnConversion() : 
  fAlgorithm(0),
  fFitStatus(0),
  fSign(0), 
  fChi2(999.), 
  fRadius(-1.), 
  fDeltaLam(999.),
  fSeparation(999.),
  fZSeparation(999.),
  fIDWord(0)
{
  fTrackNumber[0] = -1;
  fTrackNumber[1] = -1;
}

//_____________________________________________________________________________
TStnConversion::TStnConversion(Int_t It1    , Int_t It2       , 
			       const TLorentzVector& Momentum,
			       Float_t XYSep  , Float_t ZSep, Float_t DeltaLam,
			       Float_t XConv, Float_t YConv, Float_t RConv) 
{
  // radius may be negative (fakes...)

  fAlgorithm      = 0;
  fFitStatus      = 0;
  fTrackNumber[0] = It1;
  fTrackNumber[1] = It2;
  fMomentum       = Momentum;
  fSeparation     = XYSep;
  fZSeparation    = ZSep;
  fDeltaLam       = DeltaLam;
  fVertex.SetXYZ(XConv,YConv,0.);
  fRadius         = RConv;
  fSign           = 0;
  fChi2           = 999.;
  fIDWord         = 0;
}

//_____________________________________________________________________________
int TStnConversion::Init(TStnConversion* Conv) {
  // radius may be negative (fakes...)

  fAlgorithm      = Conv->fAlgorithm;
  fMomentum       = *Conv->Momentum();
  fVertex         = *Conv->Vertex();
  fFittedVertex   = *Conv->FittedVertex();

  for (int i=0; i<2; i++) {
    fTrackNumber[i] = Conv->TrackNumber(i);
    fFittedTrackMomentum[i] = *Conv->FittedTrackMomentum(i);
  }

  fSeparation     = Conv->XYSeparation();
  fZSeparation    = Conv->ZSeparation();
  fDeltaLam       = Conv->DeltaLam();
  fFittedDeltaLam = Conv->FitDeltaLam();
  fChi2           = Conv->Chi2();
  fProb           = Conv->fProb;
  fRadius         = Conv->fRadius;
  fSign           = Conv->fSign;
  fMassGamma      = Conv->fMassGamma;
  fCosGamma       = Conv->fCosGamma;
  fIDWord         = Conv->fIDWord;

  return 0;
}

//_____________________________________________________________________________
TStnConversion::~TStnConversion() {
}

//_____________________________________________________________________________
void TStnConversion::Clear(Option_t* opt) {
}

//_____________________________________________________________________________
void TStnConversion::Print(Option_t* Opt) const {
  TString opt = Opt;

  if ( (opt == "") || (opt == "banner")) {
    printf("------------------------------------------------------------------");
    printf("--------------------------------------------------------------\n");
    printf(" alg fit   id_word      R    Fit_R    Fit_Pt    Fit_Px   Fit_Py");
    printf(" Phi     Z    Trk1 Trk2  DXY    DZ    dlam   Fit_dlam   Chi2\n");
    printf("------------------------------------------------------------------");
    printf("--------------------------------------------------------------\n");
  }

  if ((opt == "data") || (opt == "")) {
    //    printf("%2d",Number());
    printf(" %3i",Algorithm());
    printf(" %3i",FitStatus());
    printf(" 0x%08x",IDWord());
    printf(" %7.3f",Radius());
    printf(" %7.3f",fFittedVertex.Pt());
    printf(" %7.3f",fMomentum.Pt());
    printf(" %7.3f",fMomentum.Px());
    printf(" %7.3f",fMomentum.Py());
    printf(" %7.3f",fFittedVertex.Phi());
    printf(" %7.3f",fFittedVertex.Z());

    printf(" %3i"   ,TrackNumber(0));
    printf(" %3i"   ,TrackNumber(1));

    printf(" %7.3f",XYSeparation());
    printf(" %7.3f",ZSeparation());
    printf(" %7.3f",DeltaLam());
    printf(" %7.3f",FitDeltaLam());
    printf(" %7.3f",Chi2());

    printf("\n");
  }
}