#ifdef __GNUG__
#pragma implementation
#endif

#include "Stntuple/obj/TStnTriggerTable.hh"
#include "Stntuple/obj/TStnTriggerBlock.hh"

ClassImp(TStnTriggerBlock)

//______________________________________________________________________________
void TStnTriggerBlock::ReadV1(TBuffer &R__b)
{
   // Read in versions 1 of class TStnTriggerBlock.

  R__b.ReadFastArray(fTsid.Data(),kNwordsV1);
}


//______________________________________________________________________________
void TStnTriggerBlock::ReadV2(TBuffer &R__b)
{
   // Read in versions 2 of class TStnTriggerBlock.
  
  R__b.ReadFastArray(fTsid.Data(),kNwordsV2);
  fTl3d.Streamer(R__b);
}

//______________________________________________________________________________
void TStnTriggerBlock::ReadV3(TBuffer &R__b)
{
   // Read in versions 3 of class TStnTriggerBlock.
  
  R__b.ReadFastArray(fTsid.Data(),kNwordsV3);
  fTl2d.Streamer(R__b);
  fTl3d.Streamer(R__b);
}

//______________________________________________________________________________
void TStnTriggerBlock::ReadV4(TBuffer &R__b) {
  // Read in versions 4,5 of class TStnTriggerBlock. At this point there was a
  // change resulting in removal of 1 word per class... (pointer to virtual
  // functions)
  // fL1Info ... fL3Info can't be restored...
  
  int buf [100];
  R__b.ReadFastArray(buf,kNwordsV3);

  memcpy(fTsid.Data(),buf   ,4*sizeof(int));
  memcpy(fTfrd.Data(),buf+ 5,11*sizeof(int));

  memcpy(fTl1d.Sumet (),buf+17,4*sizeof(int));
  memcpy(fTl1d.Caltrg(),buf+22,4*sizeof(int));
  memcpy(fTl1d.Mutrg (),buf+27,4*sizeof(int));
  memcpy(fTl1d.Trktrg(),buf+32,4*sizeof(int));
  memcpy(fTl1d.Bsctrg(),buf+37,4*sizeof(int));
  memcpy(fTl1d.Multi (),buf+42,4*sizeof(int));

				// whats left: 1 word... 

  memcpy(fL1Info.Data(),buf+47,1*sizeof(int));


  fTl2d.Streamer(R__b);
  fTl3d.Streamer(R__b);
  fTcmd.Streamer(R__b);
}

//______________________________________________________________________________
void TStnTriggerBlock::ReadV5(TBuffer &R__b) {
  // Read in version 5 of class TStnTriggerBlock. At this point there was a
  // change resulting in removal of 1 word per class... (pointer to virtual
  // functions)
  
  R__b.ReadFastArray(fTsid.Data(),kNwordsV3);

  fTl2d.Streamer(R__b);
  fTl3d.Streamer(R__b);
  fTcmd.Streamer(R__b);

}


//______________________________________________________________________________
void TStnTriggerBlock::ReadV6(TBuffer &R__b) {
  // Read in version 6 of class TStnTriggerBlock. 
  // v6 still was writing 16 words for TL1d
  
  R__b.ReadFastArray(fTsid.Data(),kNwordsV3);
  R__b.ReadFastArray(Beam,4);

  fTl2d.Streamer(R__b);
  fTl3d.Streamer(R__b);
  fTcmd.Streamer(R__b);

}


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

  Version_t version;

  if (R__b.IsReading()) {
    version = R__b.ReadVersion(); 

    for(int i=0; i<4; i++) Beam[i] = 0.0;

    if      (version == 1) ReadV1(R__b);
    else if (version == 2) ReadV2(R__b);
    else if (version == 3) ReadV3(R__b);
    else if (version == 4) ReadV4(R__b);
    else if (version == 5) ReadV5(R__b);
    else if (version == 6) ReadV6(R__b);
    else {
					// current version: 6

      R__b.ReadFastArray(fTsid.Data(),kNwordsV6);
      R__b.ReadFastArray(Beam,4);

					// read TL2D, TL3D and TCMD
      fTl2d.Streamer(R__b);
      fTl3d.Streamer(R__b);
      fTcmd.Streamer(R__b);
    }
  } 
  else {
    R__b.WriteVersion(TStnTriggerBlock::IsA());

					// write fixed part 

    R__b.WriteFastArray(fTsid.Data(),kNwordsV6);
    R__b.WriteFastArray(Beam,4);

					// write TL2D, TL3D, TCMD
    fTl2d.Streamer(R__b);
    fTl3d.Streamer(R__b);
    fTcmd.Streamer(R__b);
  }
}

//_____________________________________________________________________________
TStnTriggerBlock::TStnTriggerBlock() {
  for(int i=0; i<4; i++) Beam[i] = 0.0;
}

//_____________________________________________________________________________
TStnTriggerBlock::~TStnTriggerBlock() {
}


//_____________________________________________________________________________
Int_t TStnTriggerBlock::GetListOfPassedTriggers(const TStnTriggerTable* Table,
						const char*             Name, 
						Int_t                   Level,
						TObjArray*              List) 
{
  // assume that trigger table has been already initialized
  // if Name=0 include all passed triggers

  if (List == 0) return -1;

  List->Clear();

  if (Level == 1) {
//-----------------------------------------------------------------------------
//  L1 triggers - there are 64 bits
//-----------------------------------------------------------------------------
    for (int i=0; i<64; i++) {
      if (fTfrd.PrescaledL1Bit(i)) {
					// bit is ON, check the name

	if (i < Table->NL1Triggers()) {
	  const TStnTrigger* trig = Table->GetTrigger(1,i);
	  if ((Name == 0) || (strstr(trig->GetName(),Name) != 0)) {
	    List->Add((TObject*)trig);
	  }
	}
      }
    }
  }
  else if (Level == 2) {
//-----------------------------------------------------------------------------
//  L2 triggers : 128 bits
//-----------------------------------------------------------------------------
    TTl2dL2Decision* l2 = fTl2d.L2Decision();

    for (int i=0; i<128; i++) {
      if (l2->PrescaledBit(i)) {
					// bit is ON, check the name

	if (i < Table->NL2Triggers()) {
	  const TStnTrigger* trig = Table->GetTrigger(2,i);
	  if ((Name == 0) || (strstr(trig->GetName(),Name) != 0)) {
	    List->Add((TObject*)trig);
	  }
	}
      }
    }
  }
  else if (Level == 3) {
//-----------------------------------------------------------------------------
//  L3 triggers
//-----------------------------------------------------------------------------
    Int_t npaths = fTl3d.NPaths();

    for (int i=0; i<npaths; i++) {
      if (fTl3d.PathPassed(i)) {
					// bit is ON, check the name

	if (i < Table->NL3Triggers()) {
	  const TStnTrigger* trig = Table->GetTrigger(3,i);
	  if ((Name == 0) || (strstr(trig->GetName(),Name) != 0)) {
	    List->Add((TObject*)trig);
	  }
	}
      }
    }
  }
  else {
    Error("GetListOfTriggers","Level %i doesn't exist!\n");
  }
  return List->GetEntriesFast();
}



//_____________________________________________________________________________
void TStnTriggerBlock::Clear(Option_t* opt) {
  // Tsid, Tfrd and Tl1d are filled by memory copy, so they don't require
  // to be cleared

  fTl2d.Data()->Clear();
  fTl3d.Clear();
  fTcmd.Data()->Clear();

  fL1Info.Clear();
  fL2Info.Clear();
  fL3Info.Clear();
}

//_____________________________________________________________________________
void TStnTriggerBlock::Print(Option_t* opt) const {
  // print contents of the trigger block
					// TSID
  printf(" ---------------------------------- TSID ------------------------------\n");
  printf(" part mess_id bc bheader turn_counter B0 BC TI AM Myron L2B ev_id \n");
  printf(" ----------------------------------------------------------------------\n");
  printf(" %4i",fTsid.PartitionNumber());
  printf(" %7i",fTsid.MessageId());
  printf(" %2i",fTsid.BunchCounter());
  printf(" %6x",fTsid.BoardHeader());
  printf(" %10i",fTsid.TurnCounter());
  printf(" %2i",fTsid.B0Marker());
  printf(" %2i",fTsid.BCMarker());
  printf(" %2i",fTsid.TIMarker());
  printf(" %2i",fTsid.AbortMarker());
  printf(" %2i",fTsid.MyronBucket());
  printf(" %1i",fTsid.L2Buffer());
  printf(" %10i",fTsid.EventId());
  printf("\n");

 if (strstr(opt,"tl1d") != 0 || strstr(opt,"TL2D") != 0) {
   fTl1d.Print();
 }

 if (strstr(opt,"tl2d") == 0 || strstr(opt,"TL2D") != 0) {
   fTl2d.Print();
 }
}