///////////////////////////////////////////////////////////////////////////////
// Print Levels:
// -------------
// fPrintLevel =  1: print input data
// fPrintLevel =  2: also print reconstructed segments
// fPrintLevel = 12: print events with 11 tracks (debugging)
//
// different sets of histograms are filled for the following types of tracks:
// ----------------------------------------------------------------------------
// set 0: all the tracks
// set 1: tracks found by COT standalone (alg 2)
// set 2: tracks found by the inside-out (alg 3)
// set 3:
// set 4:
// set 5: Kal standalone    (algorithm 16)
// set 6: Kal outside-in 3D (17) 
// set 7: outside-in stereo (22)
// set 8:
// set 9:
///////////////////////////////////////////////////////////////////////////////
/*

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

  TStnAna x("results/ar0192ea.0001cmu0.stn_new");
  .L TTrackAnaModule.cc+
  x.AddModule(new TTrackAnaModule);
  TTrackAnaModule* m  = (TTrackAnaModule*) x.GetModule("TrackAna");
  m->SetDebugLevel(2);
  x.Run();

  ****** to display a histogram

  TTrackAnaModule::Hist_t* c;
  TTrackAnaModule* m  = (TTrackAnaModule*) x.GetModule("TrackAna");
  c = m->GetHist();
  c->fNTracks->Draw();

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

  x.ProcessEvent(11)
  TTrackAnaModule* m = (TTrackAnaModule*) x.GetModule("TrackAna");
  TStnTrackBlock*  trk = m->GetTrackBlock();
  TStnHeaderBlock* hdr = m->GetHeaderBlock ();
  trk->Print(); hdr->Print();

*/

#include "TF1.h"
#include "TSystem.h"
#include "Stntuple/loop/TStnAna.hh"
#include "Stntuple/obj/TStnHeaderBlock.hh"
#include "TTrackAnaModule.hh"

// ClassImp(TTrackAnaModule)
//_____________________________________________________________________________
TTrackAnaModule::TTrackAnaModule(const char* name, const char* title):
  TStnModule(name,title)
{
  fMinNTracks_101 = 0;
  fMinNTracks_101 = 0;
  fSet_101        = 0;
}

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




//_____________________________________________________________________________
void TTrackAnaModule::BookTrackHistograms(TrackHist_t& Hist, const char* Folder) {
  char name [200];
  char title[200];
				// book histograms

  sprintf(title,"%s: N Svx hits",GetName());
  HBook1F(Hist.fNSvxHits,"n_svx_hits",title,40 ,0,40,Folder);

  sprintf(title,"%s: algorithm vs N Svx RPhi hits",GetName());
  HBook1F(Hist.fNSvxRPhiHits,"n_svx_rphi_hits",title,40 ,0,40,Folder);

  sprintf(title,"%s: algorithm vs N Svx stereo hits",GetName());
  HBook1F(Hist.fNSvxStereoHits,"n_svx_stereo_hits",title,40 ,0,40,Folder);

  sprintf(title,"%s: N COT hits",GetName());
  HBook1F(Hist.fNCotHits,"n_cot_hits",title,100 ,0,100,Folder);

  sprintf(title,"%s: Algorithm",GetName());
  HBook1F(Hist.fAlgorithm,"algorithm", title,40 ,0,40,Folder);

  sprintf(title,"%s: Track Pt",GetName());
  HBook1F(Hist.fPt,"pt", title,250 ,0,50,Folder);

  sprintf(title,"%s: Track Phi0",GetName());
  HBook1F(Hist.fPhi0,"phi0", title,126 ,0,6.3,Folder);

  sprintf(title,"%s: Track Lam0",GetName());
  HBook1F(Hist.fLam0,"lam0", title,100 ,-2.5,2.5,Folder);

  sprintf(title,"%s: Track C0",GetName());
  HBook1F(Hist.fC0,"c0",title,200 ,-0.02,0.02,Folder);

  sprintf(title,"%s: Track d0",GetName());
  HBook1F(Hist.fD0,"d0", title,200 ,-10,10.,Folder);

  sprintf(title,"%s: Track z0",GetName());
  HBook1F(Hist.fZ0,"z0", title,200 ,-100,100.,Folder);

  HBook1F(Hist.fChi2,"chi2","Chi**2/NDF",250 ,0,50.,Folder);
  HBook1F(Hist.fChi2Cot,"chi2_cot","Chi**2(COT)/NDF",250 ,0,50.,Folder);
  HBook1F(Hist.fChi2Svx,"chi2_svx","Chi**2(SVX)/NDF",250 ,0,50.,Folder);
  
}


//_____________________________________________________________________________
void TTrackAnaModule::BookEventHistograms(EventHist_t& Hist,const char* Folder) 
{
  char name [200];
  char title[200];

  HBook1F(Hist.fRunNumber,"run_number","Run Number",1000,100000,200000);

  for (int i=0; i<kNTrackHistSets; i++) {
    sprintf(name, "n_tracks_%i",i);
    sprintf(title,"N tracks [%i]",i);
    HBook1F(Hist.fNTracks[i],name, title,200 ,0,200);
  }
}

//_____________________________________________________________________________
void TTrackAnaModule::BookHistograms() {

  TFolder* fol;
  TFolder* hist_folder;

  char folder_name[200];
//-----------------------------------------------------------------------------
//  clear the histogram list
//-----------------------------------------------------------------------------
  DeleteHistograms();
  hist_folder = (TFolder*) GetFolder()->FindObject("Hist");
//-----------------------------------------------------------------------------
//  individual track histograms
//-----------------------------------------------------------------------------
  for (int i=0; i<kNTrackHistSets; i++) {
    sprintf(folder_name,"trk_%i",i);
    fol = (TFolder*) hist_folder->FindObject(folder_name);
    if (! fol) fol = hist_folder->AddFolder(folder_name,folder_name);
    BookTrackHistograms(fHist.fTrack[i],Form("Hist/%s",folder_name));
  }

  BookEventHistograms(fHist.fEvent,"event");
}


//_____________________________________________________________________________
int TTrackAnaModule::BeginJob() {

				// register the data block

  RegisterDataBlock("TrackBlock"   , "TStnTrackBlock"   , &fTrackBlock);

					// book histograms
  BookHistograms();
//-----------------------------------------------------------------------------
//  handle print level
//-----------------------------------------------------------------------------
  const char* env;
  env = gSystem->Getenv(Form("%s_PrintLevel",GetName()));
  if (env) {
    fPrintLevel = atoi(env);
    printf(" %s: fPrintLevel = %i\n",GetName(),fPrintLevel);
  }

  return 0;
}


void TTrackAnaModule::FillEventHistograms(EventHist_t&    Hist) {
}

//_____________________________________________________________________________
void TTrackAnaModule::FillTrackHistograms(TrackHist_t&    Hist, 
					  TStnTrack*      Trk) {

  Hist.fAlgorithm->Fill(Trk->Algorithm());
  Hist.fNSvxHits->Fill(Trk->NSvxHits());
  Hist.fNSvxRPhiHits->Fill(Trk->NSvxRPhiHits());
  Hist.fNSvxStereoHits->Fill(Trk->NSvxStereoHits());
  Hist.fNCotHits->Fill(Trk->NCotHitsTot());
  Hist.fC0->Fill(Trk->C0());
  Hist.fD0->Fill(Trk->D0());
  Hist.fZ0->Fill(Trk->Z0());
  Hist.fLam0->Fill(Trk->Lam0());
  Hist.fPhi0->Fill(Trk->Phi0());
  Hist.fPt->Fill(Trk->Momentum()->Pt());
  Hist.fChi2->Fill(Trk->Chi2()/(Trk->NCotHitsTot()+Trk->NSvxHits()-4.9999));  
  Hist.fChi2Cot->Fill(Trk->Chi2Cot()/(Trk->NCotHitsTot()-4.9999));  
  Hist.fChi2Svx->Fill(Trk->Chi2Svx()/(Trk->NSvxHits()-4.9999));  

}


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

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

  int kInd[32] = {
     0, -1,  1,  2,  3, -1, -1, -1, -1, -1, 
    -1,  4, -1, -1, -1, -1,  5,  6, -1, -1,
    -1, -1,  7,  8,  9, -1, -1, -1, -1, -1, 
    -1, -1 
  };

  fTrackBlock->GetEntry(ientry);
					// do whatever you want
  int ntr[100], alg, ind;

  memset(ntr,0,400);

  ntr[0] = fTrackBlock->NTracks();

  for (int i=0; i<ntr[0]; i++) {
    TStnTrack* t = fTrackBlock->Track(i);
    alg = t->Algorithm();
//-----------------------------------------------------------------------------
//  set 0
//-----------------------------------------------------------------------------
    FillTrackHistograms(fHist.fTrack[0],t);

    if(PrintLevel()==11) {
      if( t->Lam0()<(-2.45) && t->Lam0()>(-2.5)) {
	GetHeaderBlock()->Print("Selected");    
      }
    }
//-----------------------------------------------------------------------------
// hists for different algorithms
//-----------------------------------------------------------------------------
    ind = kInd[alg];

    FillTrackHistograms(fHist.fTrack[ind],t);

    ntr[ind]++;
  }

  for (int i=0; i<10; i++) {
    if (kInd[i] >= 0) fHist.fEvent.fNTracks[i]->Fill(ntr[ kInd[i]]);
  }

  if (PrintLevel() == 11) {
    if ( ntr[0] == 11 ) GetHeaderBlock()->Print("ntr=11");    
  }

  if (PrintLevel() == 12) {
    if (ntr[0] == 12) GetHeaderBlock()->Print("ntr=12");    
  }

  if (PrintLevel() == 13) {
    //    GetHeaderBlock()->Print(Form("n_16 = %3i / N = %3i",n_16,ntr));
  }

  if (PrintLevel() == 14) {
    if (ntr[2] == 5) 
      GetHeaderBlock()->Print(Form("ntr[2] = %3i",ntr[2]));
  }

  if (PrintLevel() == 101) {
    
    if ((ntr[fSet_101] >= fMinNTracks_101) && (ntr[fSet_101] < fMaxNTracks_101)) {
      GetHeaderBlock()->Print(Form("ntracks[%2i]=%5i",fSet_101,ntr[fSet_101]));
    }
  }

  FillEventHistograms(fHist.fEvent);

  return 0;		       
}


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