#ifndef TClcLayer_hh
#define TClcLayer_hh

#include "TClcChannel.hh"

//_____________________________________________________________________________
class TClcLayer {
//-----------------------------------------------------------------------------
//  data members
//-----------------------------------------------------------------------------
public:
  enum {kNChannels  =  16};
public:
  Int_t          fNTdcHits;		// total number of TDC hits per layer
  Int_t          fNHitChannels;		// number of hit channels per layer
  Float_t        fMeanTime;             // measured time (good channels only)
  Float_t        fMeanTimeW;            // measured time (using width)
  TClcChannel**  fChannel;		// 16 channels/layer
  Int_t          fNUsedChannels;	// #hits used in calculation of the
					// mean time
  Int_t          fNUsedChannelsW;	// #hits used in calculation of the
					// mean time

  Float_t        fTMin;			// cuts corresponding to the last 
  Float_t        fTMax;			// calculation of the mean time
  Float_t        fAdcThreshold;		// 
  Float_t        fT0;			// ! global delay (calib const)
  Float_t        fT0W;			// ! global delay (calib const, width)
//-----------------------------------------------------------------------------
//  methods
//-----------------------------------------------------------------------------
public:

  TClcLayer();
  ~TClcLayer();
					// ****** accessors

  Int_t         NTdcHits      () { return fNTdcHits;      }
  Int_t         NUsedChannels () { return fNUsedChannels; }
  Int_t         NUsedChannelsW() { return fNUsedChannelsW;}
  Int_t         NHitChannels  () { return fNHitChannels;  }
  Float_t       MeanTime      () { return fMeanTime;      }
  Float_t       MeanTimeW     () { return fMeanTimeW;     }
  TClcChannel*  Channel  (int i) { return fChannel[i];    }
  Float_t       TMin          () { return fTMin;          }
  Float_t       TMax          () { return fTMax;          }
  Float_t       AdcThreshold  () { return fAdcThreshold;  }
  Float_t       T0            () { return fT0;             }
  Float_t       T0W           () { return fT0W;            }

					// ****** modifiers

  void          SetChannel(int i, TClcChannel* ch) { fChannel[i] = ch; }
  void          SetNTdcHits                (int n) { fNTdcHits   = n; }

  void          SetT0            (Float_t t) { fT0           = t; }
  void          SetT0W           (Float_t t) { fT0W          = t; }

					// mean time per layer should be
					// calculated explicitly

  int           CalculateMeanTime(Float_t tmin, 
				  Float_t tmax, 
				  Float_t adc_threshold);

  Int_t         NChannelsAbove(Int_t adc_threshold);
                                        // number of hits above treshold in units of spp
  Int_t         NHits(Float_t spp_treshold);

  void          Clear(Option_t* opt="");
  void          Print(Option_t* opt="");

  ClassDef(TClcLayer,1)
};

#endif