#ifndef STNTUPLE_TStnMuonBlock
#define STNTUPLE_TStnMuonBlock
//-----------------------------------------------------------------------------
//  definition of the STNTUPLE photon block
//  Author:    Pasha Murat (CDF/FNAL)
//  Date:      Oct 31 2000
// 
//  the implementation is a trade-off between the performance in split and 
//  non-split modes. I'm assuming that on a long term time scale TStnMuonBlock
//  will be written in split mode, however the TClonesArray itself may not
//  be split (if one needs tracks, he normally needs all the tracks, not only
//  track Pt)
//  Also one wants to control the streamer of the class, having a wrapper
//  around TClonesArray seems to be a reasonable compromise here
//-----------------------------------------------------------------------------

#include "TClonesArray.h"

#include <Stntuple/obj/TStnDataBlock.hh>
#include <Stntuple/obj/TStnMuon.hh>
#include <Stntuple/obj/TBaseMuonStub.hh>
#include "TStnLinkBlock.hh"
#include <Stntuple/mod/InitStntupleDataBlocks.hh>

class TStnEvent;

class TStnMuonBlock: public TStnDataBlock {
  friend Int_t StntupleInitMuonBlock(TStnDataBlock*, AbsEvent* , int);
  friend Int_t StnRun1InitMuonBlock (TStnMuonBlock*, TStnEvent*, int);
public:
//------------------------------------------------------------------------------
//  data members
//------------------------------------------------------------------------------
  Int_t          fNMuons;		// # of muons
  Int_t          fNHptm;		// # of high-Pt muons
  Int_t          fNCmio;		// # of CMIO muons
  Int_t          fNCmus;		// # of muon stubs ?
  Int_t          fCostub;
  Int_t          fNCmuStubs;
  Int_t          fNCmpStubs;
  Int_t          fNCmxStubs;
  Int_t          fNBmuStubs;
  TClonesArray*  fMuonList;
  TClonesArray*  fListOfCmuStubs;
  TClonesArray*  fListOfCmpStubs;
  TClonesArray*  fListOfCmxStubs;
  TClonesArray*  fListOfBmuStubs;
  TStnLinkBlock* fEmTowerLinkList;	// || links to the towers
  TStnLinkBlock* fHadTowerLinkList;	// || links to the towers
//-----------------------------------------------------------------------------
//  functions
//------------------------------------------------------------------------------
public:
					// ****** constructors and destructor
  TStnMuonBlock();
  virtual ~TStnMuonBlock();
					// ****** accessors

  Int_t           NMuons      () const { return fNMuons; }
  Int_t           NHptm       () const { return fNHptm;  }
  Int_t           NCmio       () const { return fNCmio;  }
  Int_t           NCmus       () const { return fNCmus;  }
  Int_t           Costub      () const { return fCostub; }
  Int_t           NCmuStubs   () const { return fNCmuStubs; }
  Int_t           NCmpStubs   () const { return fNCmpStubs; }
  Int_t           NCmxStubs   () const { return fNCmxStubs; }
  Int_t           NBmuStubs   () const { return fNBmuStubs; }

  TClonesArray*   MuonList      () const { return fMuonList; }
  TClonesArray*   ListOfCmuStubs() const { return fListOfCmuStubs; }
  TClonesArray*   ListOfCmpStubs() const { return fListOfCmpStubs; }
  TClonesArray*   ListOfCmxStubs() const { return fListOfCmxStubs; }
  TClonesArray*   ListOfBmuStubs() const { return fListOfBmuStubs; }

  TStnLinkBlock*  EmTowerLinkList() { return fEmTowerLinkList; }
  TStnLinkBlock*  HadTowerLinkList() { return fHadTowerLinkList; }


  TStnMuon*       Muon   (int i) const { 
    return (TStnMuon*) fMuonList->UncheckedAt(i); 
  }

  TBaseMuonStub*  CmuStub(int i) const { 
    return (TBaseMuonStub*) fListOfCmuStubs->UncheckedAt(i); 
  }

  TBaseMuonStub*  CmpStub(int i) const { 
    return (TBaseMuonStub*) fListOfCmpStubs->UncheckedAt(i); 
  }

  TBaseMuonStub*  CmxStub(int i) const { 
    return (TBaseMuonStub*) fListOfCmxStubs->UncheckedAt(i); 
  }

  TBaseMuonStub*  BmuStub(int i) const { 
    return (TBaseMuonStub*) fListOfBmuStubs->UncheckedAt(i); 
  }

  Int_t  TowerKey   (Int_t Imu, Int_t Itwr, TStnLinkBlock* List) { 
    return List->Index(Imu,Itwr); 
  }
   
  Int_t TowerIEta   (Int_t Imu, Int_t Itwr, TStnLinkBlock* List) { 
    int ieta = (TowerKey(Imu,Itwr,List) >> 8) & 0xff;
    return ieta;
  }
 
  Int_t TowerIPhi   (Int_t Imu, Int_t Itwr, TStnLinkBlock* List) { 
    int iphi = TowerKey(Imu,Itwr,List) & 0xff;
    return iphi;
  }
  
  Int_t TowerValidCode (Int_t Imu, Int_t Itwr, TStnLinkBlock* List) { 
    int code = (TowerKey(Imu,Itwr,List) >> 16) & 0xff;
    return code;
  }					// ****** modifiers

  void  SetNMuons() { fNMuons = fMuonList->GetEntriesFast(); }

  TStnMuon* NewMuon() {
    TStnMuon* m = new ((*fMuonList)[fNMuons]) TStnMuon(fNMuons);
    fNMuons++;
    return m;
  }

  TBaseMuonStub* NewCmuStub() {
    TBaseMuonStub* stub = new ((*fListOfCmuStubs)[fNCmuStubs]) TBaseMuonStub();
    fNCmuStubs++;
    return stub;
  }

  TBaseMuonStub* NewCmpStub() {
    TBaseMuonStub* stub = new ((*fListOfCmpStubs)[fNCmpStubs]) TBaseMuonStub();
    fNCmpStubs++;
    return stub;
  }

  TBaseMuonStub* NewCmxStub() {
    TBaseMuonStub* stub = new ((*fListOfCmxStubs)[fNCmxStubs]) TBaseMuonStub();
    fNCmxStubs++;
    return stub;
  }

  TBaseMuonStub* NewBmuStub() {
    TBaseMuonStub* stub = new ((*fListOfBmuStubs)[fNBmuStubs]) TBaseMuonStub();
    fNBmuStubs++;
    return stub;
  }
				        // return index in the block of a given
					// CdfMuon

  Int_t   MuonNumber(const CdfMuon* Ken);

					// ****** overloaded functions of 
					// TObject
  void Clear(Option_t* opt = "");
  void Print(Option_t* opt = "") const;
					// ****** schema evolution

					// read versions 1 of the block
  void ReadV1(TBuffer& R__b);
					// read versions 2 of the block
  void ReadV2(TBuffer& R__b);

  ClassDef(TStnMuonBlock,3)
};

#endif