//_____________________________________________________________________________
// Trigger analysis module: below are the examples of what one can do in 
// the interactive session
//_____________________________________________________________________________

/*

  ****** to run: 
  (note naming convention: class_name = "T"+module_name+"Module"), 
  the source code of the class is stored in 

  TStnAna x("dataval_ar0192ea_clc.root");
  x.ReloadModule("TrigAna");
  x.Run();

  ****** to display a histogram

  TTrigAnaModule::Hist_t* c;
  c = ((TTrigAnaModule*) x.GetModule("TrigAna"))->GetHist();
  c->fNBits->Draw();

  ****** to process one event (#15 in the ntuple) and to print the Trigger data

  x.ProcessEvent(15)
  TTrigAnaModule* m = (TTrigAnaModule*) x.GetModule("TrigAna");
  TStnTriggerBlock* data = m->GetTriggerBlock();
  data->Print();

*/

#include "TF1.h"
#include "TCanvas.h"
#include "TPad.h"
#include "TText.h"

#include "Stntuple/obj/TStnHeaderBlock.hh"
#include "Stntuple/obj/TStnTrackBlock.hh"

#include "TTrigAnaModule.hh"

// ClassImp(TTrigAnaModule)
//_____________________________________________________________________________
TTrigAnaModule::TTrigAnaModule(const char* name, const char* title):
  TStnModule(name,title)
{
  fMyronFlag  = -1;
}

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

//_____________________________________________________________________________
void TTrigAnaModule::BookHistograms() {
  char name [200];
  char title[200];
				// book histograms
  Delete("hist");

  // this is the right way of booking the histograms

  HBook1F(fHist.fNBits,"l1_bits","TFRD: N(L1 prescaled bits)",64 ,0,64);

  //  this is an obsolete way of booking the histograms, don't use it

  sprintf(name, "%s_l1_unprescaled",GetName());
  sprintf(title,"%s: TFRD: Unprescaled L1 Trigger bits",GetName());
  fHist.fUnprescaledBits = new TH1F(name, title,64 ,0,64);
  AddHistogram(fHist.fUnprescaledBits);
  
  sprintf(name, "%s_l1_prescaled",GetName());
  sprintf(title,"TFRD: Prescaled L1 Trigger bits");
  fHist.fPrescaledBits = new TH1F(name, title,64 ,0,64);
  AddHistogram(fHist.fPrescaledBits);

  sprintf(name, "%s_myron_flag",GetName());
  sprintf(title,"TSID: Myron Flag (L2 event buffer)");
  fHist.fMyronFlag = new TH1F(name, title,10 ,0,10);
  AddHistogram(fHist.fMyronFlag);

  sprintf(name, "%s_bunch_counter",GetName());
  sprintf(title,"TSID: Bunch Counter");
  fHist.fBunchCounter = new TH1F(name, title,200 ,0,200);
  AddHistogram(fHist.fBunchCounter);

  sprintf(name, "%s_calibration_type",GetName());
  sprintf(title,"TSID: Calibration Type");
  fHist.fCalibType = new TH1F(name, title,200 ,0,200);
  AddHistogram(fHist.fCalibType);

  sprintf(name, "%s_abort_marker",GetName());
  sprintf(title,"TSID: Abort Marker");
  fHist.fAbortMarker = new TH1F(name, title,5 ,0,5);
  AddHistogram(fHist.fAbortMarker);

  sprintf(name, "%s_b0_marker",GetName());
  sprintf(title,"TSID: Bunch Zero Marker");
  fHist.fB0Marker = new TH1F(name, title,5 ,0,5);
  AddHistogram(fHist.fB0Marker);

  sprintf(name, "%s_bc_marker",GetName());
  sprintf(title,"TSID: Bunch Crossing Marker");
  fHist.fBCMarker = new TH1F(name, title,5 ,0,5);
  AddHistogram(fHist.fBCMarker);

  for (int i=0; i<64; i++) {
    sprintf(name,"%s_l1bits_%02i",GetName(),i);
    sprintf(title,"%s: L1 bits if bit %02i is ON",GetName(),i);
    fHist.fL1Bits[i] = new TH1F(name,title,64,0,64);
    AddHistogram(fHist.fL1Bits[i]);
  }
//-----------------------------------------------------------------------------
//  TL1D histograms
//-----------------------------------------------------------------------------
  sprintf(name, "%s_tl1d_et",GetName());
  sprintf(title,"TL1D: Et");
  fHist.fTl1d.fEt = new TH1F(name, title,500 ,0,500);
  AddHistogram(fHist.fTl1d.fEt);
  
  sprintf(name, "%s_tl1d_etx",GetName());
  sprintf(title,"TL1D: Etx");
  fHist.fTl1d.fEtx = new TH1F(name, title,500 ,0,500);
  AddHistogram(fHist.fTl1d.fEtx);
  
  sprintf(name, "%s_tl1d_ety",GetName());
  sprintf(title,"TL1D: Ety");
  fHist.fTl1d.fEty = new TH1F(name, title,500 ,0,500);
  AddHistogram(fHist.fTl1d.fEty);
  
  sprintf(name, "%s_tl1d_metsq",GetName());
  sprintf(title,"TL1D: Metsq");
  fHist.fTl1d.fMetsq = new TH1F(name, title,210 ,0,2100);
  AddHistogram(fHist.fTl1d.fMetsq);

  sprintf(name, "%s_tl1d_mets",GetName());
  sprintf(title,"TL1D: Mets");
  fHist.fTl1d.fMets = new TH1F(name, title,500 ,0,500);
  AddHistogram(fHist.fTl1d.fMets);

  sprintf(name, "%s_tl2d_nclusters",GetName());
  sprintf(title,"TL2D: N(clusters)");
  fHist.fTl2d.fNClusters = new TH1F(name, title,100 ,0,100);
  AddHistogram(fHist.fTl2d.fNClusters);

  sprintf(name, "%s_tl2d_n_xtrp",GetName());
  sprintf(title,"TL2D: N(XTRP tracks)");
  fHist.fTl2d.fNXtrpTracks = new TH1F(name, title,200 ,0,200);
  AddHistogram(fHist.fTl2d.fNXtrpTracks);

  sprintf(name, "%s_tl2d_n_svt",GetName());
  sprintf(title,"TL2D: N(SVT tracks)");
  fHist.fTl2d.fNSvtTracks = new TH1F(name, title,200 ,0,200);
  AddHistogram(fHist.fTl2d.fNSvtTracks);

  for (int i=0; i<10; i++) {
    sprintf(name, "%s_event_number_%i",GetName(),i);
    sprintf(title,"Event Number");
    fHist.fEventNumber[i] = new TH1F(name, title,1000,0,50000);
    AddHistogram(fHist.fEventNumber[i]);
  }

  sprintf(name, "%s_npaths",GetName());
  sprintf(title,"Total number of L3 Paths");
  fHist.fNPaths = new TH1F(name, title,50,0,50);
  AddHistogram(fHist.fNPaths);

  sprintf(name, "%s_npassed_paths",GetName());
  sprintf(title,"Total number of passed L3 Paths");
  fHist.fNPassedPaths = new TH1F(name, title,50,0,50);
  AddHistogram(fHist.fNPassedPaths);

  HBook2F(fHist.fPassedPathVsEventNumber,"path_vs_event_number",
	  "Passed Path vs Event Number",1000,0,50000,30,0,30);

}


//_____________________________________________________________________________
int TTrigAnaModule::BeginJob() {

				// register the data block

  RegisterDataBlock("TriggerBlock","TStnTriggerBlock",&fTriggerBlock);

				// book histograms
  BookHistograms();

  return 0;
}


//_____________________________________________________________________________
int TTrigAnaModule::BeginRun() {
  return 0;
}

//_____________________________________________________________________________
int TTrigAnaModule::Event(int ientry) {

  fTriggerBlock->GetEntry(ientry);
  TStnHeaderBlock* header = GetHeaderBlock();
//-----------------------------------------------------------------------------
//  no trigger histograms for MC events so far
//-----------------------------------------------------------------------------
  if (header->McFlag()) return 1;
  					// do whatever you want
  if (PrintLevel()) {
    fTriggerBlock->Print();
  }

  TTsid* tsid = fTriggerBlock->Tsid();
  TTfrd* tfrd = fTriggerBlock->Tfrd();
  TTl1d* tl1d = fTriggerBlock->Tl1d();
  TTl2d* tl2d = fTriggerBlock->Tl2d();
  TTl3d* tl3d = fTriggerBlock->Tl3d();


				// hex print

  int nw = tl2d->Data()->NDataWords();

//    int k = 0;
//    for (int i=0; i<nw; i++) {
//      printf("%08x ",tl2d->Data()->At(i));
//      k++;
//      if (k == 10) {
//        printf("\n");
//        k = 0;
//      }
//    }
//    if (k != 0) {
//      printf("\n");
//      k = 0;
//    }

//    printf(" nw, N(L1), n(XTRP), n(SVT) : %i %i %i %i \n",nw,
//  	 tl2d->NL1Words(),
//  	 tl2d->NXtrpTracks(),
//  	 tl2d->NSvtTracks()
//  	 );

//    for (int i=0; i<tl2d->NXtrpTracks(); i++) {
//      TTl2dXtrpTrack* t = tl2d->Tl2dXtrpTrack(i);
//      printf(" i, wedge, pt_bin, iso_bit : %3i %3i %3i %3i \n",
//  	   i,t->LinkerPhiWedge(),t->PtBin(),t->IsolationBit());
//    }

  fHist.fMyronFlag->Fill(tsid->MyronFlag());
  fHist.fBunchCounter->Fill(tsid->BunchCounter());
  fHist.fCalibType->Fill(tsid->CalibType());
  fHist.fAbortMarker->Fill(tsid->AbortMarker());
  fHist.fB0Marker->Fill(tsid->B0Marker());
  fHist.fBCMarker->Fill(tsid->BCMarker());
  
  int n_prescaled_bits = 0;
  for (int i=0; i<64; i++) {
    if (tfrd->UnprescaledL1Bit(i)) {
      fHist.fUnprescaledBits->Fill(i);
    }
    if (tfrd->PrescaledL1Bit(i)) {
      fHist.fPrescaledBits->Fill(i);
      n_prescaled_bits++;
				// fill correlation histograms
      for (int j=0; j<64; j++) {
	if (tfrd->PrescaledL1Bit(j)) {
	  fHist.fL1Bits[i]->Fill(j);
	}
      }
    }
  }
  fHist.fNBits->Fill(n_prescaled_bits);

//-----------------------------------------------------------------------------
//  fill TL1D histograms
//-----------------------------------------------------------------------------
  TSumet* sumet = tl1d->Sumet();

  fHist.fTl1d.fEt->Fill(sumet->Et());
  fHist.fTl1d.fEtx->Fill(sumet->Etx());
  fHist.fTl1d.fEty->Fill(sumet->Ety());
  fHist.fTl1d.fMetsq->Fill(sumet->Metsq());
  fHist.fTl1d.fMets->Fill(sqrt((double)sumet->Metsq()));
//-----------------------------------------------------------------------------
//  fill TL2D histograms
//-----------------------------------------------------------------------------
  fHist.fTl2d.fNClusters->Fill(tl2d->NL2Clusters());
  fHist.fTl2d.fNXtrpTracks->Fill(tl2d->NXtrpTracks());
  fHist.fTl2d.fNSvtTracks->Fill(tl2d->NSvtTracks());
//-----------------------------------------------------------------------------
//  fill TL3D-related histograms
//-----------------------------------------------------------------------------
  int iev = header->EventNumber();
  int xmax = (int) fHist.fEventNumber[0]->GetXaxis()->GetXmax();
  int ihist = iev/xmax;
  if (ihist < 10) {
    for (int i=0; i<ihist+1; i++) {
      fHist.fEventNumber[ihist]->Fill(iev%xmax);
    }
  }

  int npassed = 0;
  fHist.fNPaths->Fill(tl3d->NPaths());
  for (int i=0; i<tl3d->NPaths(); i++) {
    if (tl3d->PathPassed(i) != 0) {
      fHist.fPassedPathVsEventNumber->Fill(header->EventNumber(),i,1);
      npassed++;
    }
  }
  fHist.fNPassedPaths->Fill(npassed);
  
  return 0;			       
}


//_____________________________________________________________________________
int TTrigAnaModule::EndJob() {
  printf("----- end job: ---- %s\n",GetName());
  return 0;
}


//_____________________________________________________________________________
void TTrigAnaModule::PlotHistograms(int run_number, int slide) {
  // plot slides

  char name[120], canvas_name[120], title[120], pad_name[120];

  sprintf(name,"run_%i_%i",run_number,slide);

  sprintf(title,"run %i slide %i ",run_number, slide);

  sprintf(canvas_name,"%s_%s",GetName(),name);
  sprintf(pad_name,"%s_p1",canvas_name);

  if (slide == 1) {
//-----------------------------------------------------------------------------
//  TFRD and TSID
//-----------------------------------------------------------------------------
    //    TPostScript ps("l1ana.ps",-111);

    TCanvas* c = NewSlide(name,title,2,3);
    TPad* p1 = (TPad*) c->GetPrimitive(pad_name);

    p1->cd(1); 
    gPad->SetLogy();
    fHist.fBunchCounter->Draw();

    p1->cd(2); 
    gPad->SetLogy();
    fHist.fUnprescaledBits->Draw();

    p1->cd(3); 
    gPad->SetLogy();
    fHist.fPrescaledBits->Draw();

    p1->cd(4); 
    fHist.fB0Marker->Draw();

    p1->cd(5); 
    fHist.fBCMarker->Draw();

    p1->cd(6); 
    fHist.fMyronFlag->Draw();

    gPad->Update();
  }
  else if (slide == 2) {
//-----------------------------------------------------------------------------
//  TL1D
//-----------------------------------------------------------------------------
    //    TPostScript ps("l1ana.ps",-111);

    TCanvas* c = NewSlide(name,title,2,3);
    TPad* p1 = (TPad*) c->GetPrimitive(pad_name);

    p1->cd(1);
    gPad->SetLogy();
    fHist.fTl1d.fEt->Draw();

    p1->cd(2); 
    gPad->SetLogy();
    fHist.fTl1d.fEtx->Draw();

    p1->cd(3); 
    gPad->SetLogy();
    fHist.fTl1d.fEty->Draw();

    p1->cd(4); 
    gPad->SetLogy();
    fHist.fTl1d.fMetsq->Draw();

    p1->cd(5); 
    gPad->SetLogy();
    fHist.fTl1d.fMets->Draw();

    gPad->Update();
  }
  else if (slide == 3) {
//-----------------------------------------------------------------------------
//  TL3D
//-----------------------------------------------------------------------------
    //    TPostScript ps("l1ana.ps",-111);

    strcat(title," (TL3D)");
    TCanvas* c = NewSlide(name,title,2,3);
    TPad* p1 = (TPad*) c->GetPrimitive(pad_name);

    p1->cd(1);
    fHist.fEventNumber[0]->SetMaximum(1000);
    fHist.fEventNumber[0]->Draw();
    for (int i=0; i<10; i++) {
      fHist.fEventNumber[i]->Draw("same");
    }

    p1->cd(2); 
    fHist.fNPaths->Draw();

    p1->cd(3); 
    fHist.fPassedPathVsEventNumber->Draw();

    p1->cd(4); 
    fHist.fNPassedPaths->Draw();

    gPad->Update();
  }
}