///////////////////////////////////////////////////////////////////////////////
//  Apr 15 2001 P.Murat: description of the STNTUPLE muon block
///////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <iomanip>

#include <Stntuple/obj/TBaseMuonStub.hh>
#include <Stntuple/obj/TStnMuonBlock.hh>

ClassImp(TStnMuonBlock)
//______________________________________________________________________________
void TStnMuonBlock::ReadV1(TBuffer &R__b)
{
  // read version 1 of TStnMuonBlock

  R__b >> fNMuons;
  R__b >> fNHptm;
  R__b >> fNCmio;
  R__b >> fNCmus;
  R__b >> fCostub;
  fMuonList->Streamer(R__b);
}


//______________________________________________________________________________
void TStnMuonBlock::ReadV2(TBuffer &R__b)
{
  // read version 2 of TStnMuonBlock

  Int_t nwint = &fNCmxStubs-&fNMuons+1;

  R__b.ReadFastArray(&fNMuons,nwint);
  fNBmuStubs = 0;

  if (fNMuons > 0) {
    fMuonList->Streamer(R__b);
  }
  if (fNCmuStubs > 0) {
    fListOfCmuStubs->Streamer(R__b);
  }
  if (fNCmpStubs > 0) {
    fListOfCmpStubs->Streamer(R__b);
  }
  if (fNCmxStubs > 0) {
    fListOfCmxStubs->Streamer(R__b);
  }
}


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

  Int_t nwint = &fNBmuStubs-&fNMuons+1;

  if (R__b.IsReading()) {
//-----------------------------------------------------------------------------
//  read section
//-----------------------------------------------------------------------------
    Version_t R__v = R__b.ReadVersion(); 
    if      (R__v == 1) { 
					// read V1
      ReadV1(R__b);
    }
    else if (R__v == 2) { 
					// read V2
      ReadV2(R__b);
    }
    else {
//-----------------------------------------------------------------------------
// current version: 3
//-----------------------------------------------------------------------------
      R__b.ReadFastArray(&fNMuons,nwint);
      if (fNMuons > 0) {
	fMuonList->Streamer(R__b);
	fEmTowerLinkList->Streamer(R__b);
	fHadTowerLinkList->Streamer(R__b);
//-----------------------------------------------------------------------------
// kludge around missing numbering
//-----------------------------------------------------------------------------
	for (int i=0; i<fNMuons; i++) {
	  Muon(i)->SetNumber(i);
	}
      }
      if (fNCmuStubs > 0) {
	fListOfCmuStubs->Streamer(R__b);
      }
      if (fNCmpStubs > 0) {
	fListOfCmpStubs->Streamer(R__b);
      }
      if (fNCmxStubs > 0) {
	fListOfCmxStubs->Streamer(R__b);
      }
    }
  } 
  else {
//-----------------------------------------------------------------------------
//  write section: current version 3
//-----------------------------------------------------------------------------
    R__b.WriteVersion(TStnMuonBlock::IsA());

    R__b.WriteFastArray(&fNMuons,nwint);
    if (fNMuons > 0) {
      fMuonList->Streamer(R__b);
      fEmTowerLinkList->Streamer(R__b);
      fHadTowerLinkList->Streamer(R__b);
    }
    if (fNCmuStubs > 0) {
      fListOfCmuStubs->Streamer(R__b);
    }
    if (fNCmpStubs > 0) {
      fListOfCmpStubs->Streamer(R__b);
    }
    if (fNCmxStubs > 0) {
      fListOfCmxStubs->Streamer(R__b);
    }
  }
}

//_____________________________________________________________________________
TStnMuonBlock::TStnMuonBlock() {
  fNMuons    = 0;
  fNCmio     = 0;
  fNCmuStubs = 0;
  fNCmpStubs = 0;
  fNCmxStubs = 0;
  fNBmuStubs = 0;

  fMuonList       = new TClonesArray("TStnMuon",10);
  fMuonList->BypassStreamer(kFALSE);
  fListOfCmuStubs = new TClonesArray("TBaseMuonStub",10);
  fListOfCmuStubs->BypassStreamer(kFALSE);
  fListOfCmpStubs = new TClonesArray("TBaseMuonStub",10);
  fListOfCmpStubs->BypassStreamer(kFALSE);
  fListOfCmxStubs = new TClonesArray("TBaseMuonStub",10);
  fListOfCmxStubs->BypassStreamer(kFALSE);
  fListOfBmuStubs = new TClonesArray("TBaseMuonStub",10);
  fListOfBmuStubs->BypassStreamer(kFALSE);
  fEmTowerLinkList = new TStnLinkBlock();
  fHadTowerLinkList = new TStnLinkBlock();
}


//_____________________________________________________________________________
TStnMuonBlock::~TStnMuonBlock() {
  fMuonList->Delete();
  delete fMuonList;

  fListOfCmuStubs->Delete();
  delete fListOfCmuStubs;

  fListOfCmpStubs->Delete();
  delete fListOfCmpStubs;

  fListOfCmxStubs->Delete();
  delete fListOfCmxStubs;

  fListOfBmuStubs->Delete();
  delete fListOfBmuStubs;

  delete fEmTowerLinkList;
  delete fHadTowerLinkList;
}


//_____________________________________________________________________________
void TStnMuonBlock::Clear(const char* opt) {

  fLinksInitialized = 0;

  fNMuons    = 0;
  fNCmuStubs = 0;
  fNCmpStubs = 0;
  fNCmxStubs = 0;
  fNBmuStubs = 0;

  fMuonList->Clear();
  fListOfCmuStubs->Clear();
  fListOfCmpStubs->Clear();
  fListOfCmxStubs->Clear();
  fListOfBmuStubs->Clear();

  fEmTowerLinkList->Clear();
  fHadTowerLinkList->Clear();
}

//_____________________________________________________________________________
void TStnMuonBlock::Print(const char* opt) const {
  if (NMuons() > 0) {
    Muon(0)->Print("banner");
    for (int i=0; i<fNMuons; i++) {
      Muon(i)->SetNumber(i);
      Muon(i)->Print("");
    }
  }
  else {
    printf("TStnMuonBlock::Print: no muons in the event\n");
  }
}


//_____________________________________________________________________________
Int_t TStnMuonBlock::MuonNumber(const CdfMuon* Ken) 
{
  // for given CdfMuon return its number in *this, which is supposed
  // to be initialized for a given event

  Int_t im = -1;
  TStnMuon* mu;

  for (int i=0; i<fNMuons; i++) {
    mu = Muon(i);
    if (mu->GetCdfMuon() == Ken) {
      im = i;
      break;
    }
  }
  return im;
}