#ifndef STNTUPLE_TStnClusterBlock
#define STNTUPLE_TStnClusterBlock
//-----------------------------------------------------------------------------
//  definition of the STNTUPLE CES/CPR/PES Cluster block
//  Author:    Ray Culbertson (CDF/FNAL)
//  Date:      Jan 31 2001
// 

#include "TClonesArray.h"

#include <Stntuple/obj/TStnDataBlock.hh>
#include <Stntuple/obj/TStnClusterBlock.hh>
#include <Stntuple/data/TCesCluster.hh>
#include <Stntuple/data/TCprCluster.hh>
#include <Stntuple/data/TPesCluster.hh>

class TStnClusterBlock: public TStnDataBlock {
public:
//----------------------------------------------------------------------------
//  data members
//-----------------------------------------------------------------------------
  Int_t          fNCesTrkClusters;
  Int_t          fNCesUnbClusters;
  Int_t          fNCprTrkClusters;
  Int_t          fNCprUnbClusters;
  Int_t          fNPesClusters;
  TClonesArray*  fCesTrkClusterList;
  TClonesArray*  fCesUnbClusterList;
  TClonesArray*  fCprTrkClusterList;
  TClonesArray*  fCprUnbClusterList;
  TClonesArray*  fPesClusterList;
//----------------------------------------------------------------------------
//  transient-only variables - need to be initialized before use
//----------------------------------------------------------------------------
  TObjArray*     fCesU[2][24][2]; // ! clusters ordered by wedge and side
//----------------------------------------------------------------------------
//  functions
//----------------------------------------------------------------------------
public:
					// ****** constructors and destructor
  TStnClusterBlock();
  virtual ~TStnClusterBlock();
					// ****** accessors


  Int_t           NCesTrkClusters   () const { return fNCesTrkClusters; }
  TClonesArray*   CesTrkClusterList () const { return fCesTrkClusterList; }
  TCesCluster*     CesTrkCluster(int i) { 
    return (TCesCluster*) fCesTrkClusterList->UncheckedAt(i); 
  }
  TCesCluster*     NewCesTrkCluster() { 
    return new ((*fCesTrkClusterList)[fNCesTrkClusters++]) TCesCluster(); 
  }

  Int_t           NCesUnbClusters   () const { return fNCesUnbClusters; }
  TClonesArray*   CesUnbClusterList () const { return fCesUnbClusterList; }
  TCesCluster*     CesUnbCluster(int i) { 
    return (TCesCluster*) fCesUnbClusterList->UncheckedAt(i); 
  }
  TCesCluster*     NewCesUnbCluster() { 
    return new ((*fCesUnbClusterList)[fNCesUnbClusters++]) TCesCluster(); 
  }
//-----------------------------------------------------------------------------
// transient-only, View: HARDWARE convention: 0: strips, : wires
// do not consider track-based clusters 
//-----------------------------------------------------------------------------
  Int_t           NCesClusters(Int_t Side, Int_t Wedge) {
    return fCesU[Side][Wedge][0]->GetEntriesFast()+
      fCesU[Side][Wedge][1]->GetEntriesFast();
  }

  Int_t           NCesClusters(Int_t Side, Int_t Wedge, Int_t View) {
    return fCesU[Side][Wedge][View]->GetEntriesFast();
  }

  TCesCluster*    GetCesCluster(Int_t Side, Int_t Wedge, Int_t View, Int_t I) {
    return (TCesCluster*) fCesU[Side][Wedge][View]->UncheckedAt(I);
  }
//-----------------------------------------------------------------------------
// CPR
//-----------------------------------------------------------------------------
  Int_t           NCprTrkClusters   () const { return fNCprTrkClusters; }
  TClonesArray*   CprTrkClusterList () const { return fCprTrkClusterList; }
  TCprCluster*     CprTrkCluster(int i) { 
    return (TCprCluster*) fCprTrkClusterList->UncheckedAt(i); 
  }
  TCprCluster*     NewCprTrkCluster() { 
    return new ((*fCprTrkClusterList)[fNCprTrkClusters++]) TCprCluster(); 
  }

  Int_t           NCprUnbClusters   () const { return fNCprUnbClusters; }
  TClonesArray*   CprUnbClusterList () const { return fCprUnbClusterList; }
  TCprCluster*     CprUnbCluster(int i) { 
    return (TCprCluster*) fCprUnbClusterList->UncheckedAt(i); 
  }
  TCprCluster*     NewCprUnbCluster() { 
    return new ((*fCprUnbClusterList)[fNCprUnbClusters++]) TCprCluster(); 
  }
//-----------------------------------------------------------------------------
// PES
//-----------------------------------------------------------------------------
  Int_t           NPesClusters   () const { return fNPesClusters; }
  TClonesArray*   PesClusterList () const { return fPesClusterList; }
  TPesCluster*     PesCluster(int i) { 
    return (TPesCluster*) fPesClusterList->UncheckedAt(i); 
  }
  TPesCluster*     NewPesCluster() { 
    return new ((*fPesClusterList)[fNPesClusters++]) TPesCluster(); 
  }
//-----------------------------------------------------------------------------
// other methods
//-----------------------------------------------------------------------------
  void    InitCesRecoArrays();
//-----------------------------------------------------------------------------
// overloaded functions of TObject
//-----------------------------------------------------------------------------
  void Clear(Option_t* opt="");
  void Print(Option_t* opt="") const;

  ClassDef(TStnClusterBlock,1)
};












#endif