//-----------------------------------------------------------------------------
// EmTiming recon data block
// Oct 20, 2003 - RLC
//
//-----------------------------------------------------------------------------
#include "TBuffer.h"

#include "Stntuple/obj/TStnEmTimingBlock.hh"


ClassImp(TStnEmTimingBlock)

//___________________________________________________________________________
TStnEmTimingBlock::TStnEmTimingBlock(){
  Clear();
}

//___________________________________________________________________________
TStnEmTimingBlock::~TStnEmTimingBlock() {
}

//___________________________________________________________________________
void TStnEmTimingBlock::Clear(Option_t* opt) {
  fNHits = 0;
  fHits.Clear();
  fTimes.Clear();
  fWidths.Clear();
}

//___________________________________________________________________________
void TStnEmTimingBlock::Print(Option_t* opt) const {
  printf("************* EmTiming Block ************* %i Hits\n",fNHits);
  printf("      wedge  eta  det  time  width status\n");
  for(int i=0; i<fNHits; i++) {
    printf("%4i %6i %6i  %1i   %7.2f  %7.2f  0x%04x\n",i,IPhi(i),IEta(i),
	   Det(i),Time(i),Width(i),Status(i));
  }
}

//___________________________________________________________________________
Int_t TStnEmTimingBlock::AddHit(Int_t wedge, Int_t ieta, Int_t det, 
				Float_t time, Float_t width, Int_t status) {
  if(fNHits>=10000) return 1;
  fHits.Set(fNHits+1);
  fHits[fNHits] = ((ieta&0x3F)<<6) | (wedge&0x3F) | 
    ((det&0x7)<<12) | ((status&0xFFFF)<<16);
  fTimes.Set(fNHits+1);
  fTimes[fNHits] = time;
  fWidths.Set(fNHits+1);
  fWidths[fNHits] = width;
  fNHits++;
  return 0;
}

//____________________________________________________________________________
void TStnEmTimingBlock::Streamer(TBuffer &R__b)
{
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion();
      TObject::Streamer(R__b);
      R__b >> fNHits;
      fHits.Streamer(R__b);
      fTimes.Streamer(R__b);
      if(R__v>=2) {
	fWidths.Streamer(R__b);
      } else {
	fWidths.Clear();
      }
   } else {
      R__b.WriteVersion(TStnEmTimingBlock::IsA());
      TObject::Streamer(R__b);
      R__b << fNHits;
      fHits.Streamer(R__b);
      fTimes.Streamer(R__b);
      fWidths.Streamer(R__b);
   }
}

//____________________________________________________________________________

typedef enum{thFitStatus=0,slFitStatus=2,abThresh=4,threshSigma=5,lowEff=8,
	     highThresh=9,slowTurn=10,lowEneSl=11,highEneSl=12,
	     badSlewChi2=13,pmt0Bad=14,pmt1Bad=15} CalibBitShifts;

Bool_t TStnEmTimingBlock::IsCalibrated(Int_t status) {
  if( ((status>>thFitStatus)&3) < 2) return false;
  if( ((status>>slFitStatus)&3) < 2) return false;
  return true;}
Bool_t TStnEmTimingBlock::IsNormalTower(Int_t status) { 
  return ((!IsLowEfficiency(status))&&(!IsHighThreshold(status))&&(!IsWideRMS(status))); }
Bool_t TStnEmTimingBlock::IsLowEfficiency(Int_t status) {
  return ((status&(1<<lowEff))>0);}
Bool_t TStnEmTimingBlock::IsHighThreshold(Int_t status) {
  return ((status&(1<<highThresh))>0);}
Bool_t TStnEmTimingBlock::IsWideRMS(Int_t status) {
  return ((status&(1<<slowTurn))>0);}
Bool_t TStnEmTimingBlock::EventAboveThreshold(Int_t status) {
  return ((status&(1<<abThresh))>0);}
Int_t  TStnEmTimingBlock::SigmasFromThreshold(Int_t status) { 
  return ((status>>threshSigma)&7);}
Bool_t TStnEmTimingBlock::IsPoorCalibFit(Int_t status) {
  return ((status&(1<<badSlewChi2))>0);}
Bool_t TStnEmTimingBlock::EnergyTooLow(Int_t status) { 
  return ((status&(1<<lowEneSl))>0);}
Bool_t TStnEmTimingBlock::EnergyTooHigh(Int_t status) { 
  return ((status&(1<<highEneSl))>0);}
Bool_t TStnEmTimingBlock::GoodEventEnergy(Int_t status) { 
  return ((!EnergyTooLow(status))&&(!EnergyTooHigh(status))&&
	  (EventAboveThreshold(status))); }
Bool_t TStnEmTimingBlock::IsPmt0Bad(Int_t status) { 
  return ((status&(1<<pmt0Bad))>0);}
Bool_t TStnEmTimingBlock::IsPmt1Bad(Int_t status) { 
  return ((status&(1<<pmt1Bad))>0); }