//-*-mode:c++; mode:font-lock;-*-
//Program to Test BuildIndex for Very large TTrees



#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <cmath>
#include <time.h>

#include "TFile.h"
#include "TROOT.h"
#include "TTree.h"
#include "TBranch.h"
#include "TTreeIndex.h"
#include "TObject.h"
#include "TRandom2.h"

class RootPeData
// *******************************************************
// class to hold single pe's
// *******************************************************
{
 public:
  RootPeData(){};
  ~RootPeData(){};
  int    fNx;              // Grid coords (x,y)
  int    fNy;
  double fTime;            // Time of hit
  double fPhotonDl;        // dl of photon 
  double fPhotonDm;        // dm of photon(dn can be recreated)
  int    fSegmentID;       // Segment identifier.
  double fX;               // X position of hit in grid rectangle.
  double fY;               // Y position of hit in grid rectangle.
  int    fTrackType;       // Type of emitting particle.
  int    fLambda;          // Wavelength of emmited photon(nm)
  double fEmissionAltitude;// emmison altitude
};

const int kNumPeToMake=61000000;
const int kNxNyMax=12000;

int main(int argc, char** argv)
{ 
  TRandom2* pran = new TRandom2(0);
  RootPeData* pfRootPe = new RootPeData();

  TFile* pfTempTreeFile = (TFile*) new TFile("SortTempTreeFile.root", 
				   "RECREATE","Temporary Sort ROOT file");
  pfTempTreeFile->cd();

  TTree* pfPeTree=new TTree("PeTree","Pe Tree");

  pfPeTree->Branch("fNx",&pfRootPe->fNx,"fNx/I");
  pfPeTree->Branch("fNy",&pfRootPe->fNy,"fNy/I");
  pfPeTree->Branch("fTime",&pfRootPe->fTime,"fTime/D");
  pfPeTree->Branch("fPhotonDl",&pfRootPe->fPhotonDl,"fPhotonDl/D");
  pfPeTree->Branch("fPhotonDm",&pfRootPe->fPhotonDm,"fPhotonDm/D");
  pfPeTree->Branch("fSegmentID",&pfRootPe->fSegmentID,"fSegmentID/I");
  pfPeTree->Branch("fX",&pfRootPe->fX,"fX/D");
  pfPeTree->Branch("fY",&pfRootPe->fY,"fY/D");
  pfPeTree->Branch("fTrackType",&pfRootPe->fTrackType,"fTrackType/I");
  pfPeTree->Branch("fLambda",&pfRootPe->fLambda,"fLambda/I");
  pfPeTree->Branch("fEmissionAltitude",&pfRootPe->fEmissionAltitude,
		   "fEmissionAltitude/D");


  pfRootPe->fTime=0;
  pfRootPe->fPhotonDl=0;
  pfRootPe->fPhotonDm=0; 
  pfRootPe->fSegmentID=0;
  pfRootPe->fX=0;        
  pfRootPe->fY=0;        
  pfRootPe->fTrackType=0;
  pfRootPe->fLambda=0;  
  pfRootPe->fEmissionAltitude=0;


  int nxmin=0;
  int nymin=0;
  int j=1000000;
  bool fPeFill=true;
  //bool fPeFill=false;

  for(int i=0;i<kNumPeToMake;i++)
    {
      pfRootPe->fNx=(int)(pran->Rndm(0)*2*kNxNyMax) - kNxNyMax;
      pfRootPe->fNy=(int)(pran->Rndm(0)*2*kNxNyMax) - kNxNyMax;
      if(pfRootPe->fNx<nxmin)
	{
	  nxmin=pfRootPe->fNx;
	}
      if(pfRootPe->fNy<nymin)
	{
	  nymin=pfRootPe->fNy;
	}
      if(fPeFill)
	{
	  pfRootPe->fTime=(int)pran->Rndm(0)*1000;
	  pfRootPe->fPhotonDl=pran->Rndm(0)*1000;
	  pfRootPe->fPhotonDm=pran->Rndm(0)*1000; 
	  pfRootPe->fSegmentID=(int)(pran->Rndm(0)*1000);
	  pfRootPe->fX=pran->Rndm(0)*1000;        
	  pfRootPe->fY=pran->Rndm(0)*1000;        
	  pfRootPe->fTrackType=(int)(pran->Rndm(0)*1000);
	  pfRootPe->fLambda=(int)(pran->Rndm(0)*1000);  
	  pfRootPe->fEmissionAltitude=pran->Rndm(0)*1000;
	}
      pfPeTree->Fill();
      if(i%j==0)
	{
	  std::cout<<"i:"<<i<<std::endl;
	}
    }
  pfPeTree->Write();
  pfPeTree->Print();

  int fNumEntries=pfPeTree->GetEntries();

  std::cout<<"LargeTTreeTest2: Number of PEs in tree: "<<fNumEntries
	   <<std::endl;
  std::cout<<"LargeTTreeTest2: NX minimum= "<<nxmin<<std::endl;
  std::cout<<"LargeTTreeTest2: NY minimum= "<<nymin<<std::endl;

  int fNumIndexes=pfPeTree->BuildIndex("fNx+12001","fNy+12001");  

  std::cout<<"LargeTTreeTest2: fNumIndexes: "<<fNumIndexes<<std::endl;


  return 0;
}