#include<stdio.h>
#include<iostream.h>
#include<TFile.h>
#include<TTree.h>
#include<math.h>
#include <sstream>
#include <string>
#include <fstream.h>
 using namespace std;
int conv()
{

std::ifstream in;
 in.open("data.dat");
   TFile *f = new TFile("MAAB.root","recreate");
   TTree *t = new TTree ("signal","data from ascii file");
// some declarations 
Double_t  eta,phi,m,bt,em,d1,d2,nt,pt;
Int_t Event_N=0,k=0,idx,ty,Trigger;


Int_t Ele_N,Jet_N,Muon_N,Tau_N,Photon_N;

Double_t Miss_Phi,Miss_Px,Miss_Py,Miss_E;

Double_t  Photon_Eta[5],Photon_Phi[5],Photon_Px[5],Photon_Py[5],Photon_Pz[5],Photon_E[5],Photon_Pt[5],Photon_isem[5];

Double_t  Ele_Eta[5],Ele_Phi[5],Ele_Px[5],Ele_Py[5],Ele_Pz[5],Ele_E[5],Ele_Pt[5],Ele_isem[5],Ele_charge[5];

Double_t  Muon_Eta[5],Muon_Phi[5],Muon_Px[5],Muon_Py[5],Muon_Pz[5],Muon_E[5],Muon_Pt[5],Muon_isem[5],Muon_charge[5],Muon_siso[5];

Double_t  Tau_Eta[5],Tau_Phi[5],Tau_Px[5],Tau_Py[5],Tau_Pz[5],Tau_E[5],Tau_Pt[5],Tau_isem[5],Tau_traN[5];

Double_t  Jet_Eta[20],Jet_Phi[20],Jet_Px[20],Jet_Py[20],Jet_Pz[20],Jet_E[20],Jet_Pt[20],Jet_isem[20],Jet_m[20],Jet_traN[20] ;
Int_t Jet_b[20];
//here I creat the leave
t->Branch("Jet_N",&Jet_N,"Jet_N/I");         // N jets
t->Branch("Ele_N",&Ele_N,"Ele_N/I");      // N elctrons
t->Branch("Muon_N",&Muon_N,"Muon_N/I");      // N muons
t->Branch("Tau_N",&Tau_N,"Tau_N/I");         // N taus
t->Branch("Photon_N",&Photon_N,"Photon_N/I");         // N photons 
t->Branch("Trigger",&Trigger,"Trigger/I");        //Trigger information

//Photons
t->Branch("Photon_Eta",Photon_Eta,"Photon_Eta[Photon_N]/D");
t->Branch("Photon_Phi",Photon_Phi,"Photon_Phi[Photon_N]/D");
t->Branch("Photon_Px",Photon_Px,"Photon_Px[Photon_N]/D");
t->Branch("Photon_Py",Photon_Py,"Photon_Py[Photon_N]/D");
t->Branch("Photon_Pz",Photon_Pz,"Photon_Pz[Photon_N]/D");
t->Branch("Photon_E",Photon_E,"Photon_E[Photon_N]/D");
t->Branch("Photon_Pt",Photon_Eta,"Photon_Pt[Photon_N]/D");
t->Branch("Photon_isem",Photon_isem,"Photon_isem[Photon_N]/D");

//jets
t->Branch("Jet_Eta",Jet_Eta,"Jet_Eta[Jet_N]/D");
t->Branch("Jet_Phi",Jet_Phi,"Jet_Phi[Jet_N]/D");
t->Branch("Jet_Px",Jet_Px,"Jet_Px[Jet_N]/D");
t->Branch("Jet_Py",Jet_Py,"Jet_Py[Jet_N]/D");
t->Branch("Jet_Pz",Jet_Pz,"Jet_Pz[Jet_N]/D");
t->Branch("Jet_E",Jet_E,"Jet_E[Jet_N]/D");
t->Branch("Jet_Pt",Jet_Eta,"Jet_Pt[Jet_N]/D");
t->Branch("Jet_isem",Jet_isem,"Jet_isem[Jet_N]/D");
t->Branch("Jet_traN",Jet_traN,"Jet_traN[Jet_N]/D");
t->Branch("Jet_m",Jet_m,"Jet_m[Jet_N]/D");
t->Branch("Jet_b",Jet_b,"Jet_b[Jet_N]/I");



//electrons
t->Branch("Ele_Eta",Ele_Eta,"Ele_Eta[Ele_N]/D");
t->Branch("Ele_Phi",Ele_Phi,"Ele_Phi[Ele_N]/D");
t->Branch("Ele_Px",Ele_Px,"Ele_Px[Ele_N]/D");
t->Branch("Ele_Py",Ele_Py,"Ele_Py[Ele_N]/D");
t->Branch("Ele_Pz",Ele_Pz,"Ele_Pz[Ele_N]/D");
t->Branch("Ele_E",Ele_E,"Ele_E[Ele_N]/D");
t->Branch("Ele_Pt",Ele_Pt,"Ele_Pt[Ele_N]/D");
t->Branch("Ele_isem",Ele_isem,"Ele_isem[Ele_N]/D");
t->Branch("Ele_charge",Ele_charge,"Ele_charge[Ele_N]/D");

//muons
t->Branch("Muon_Eta",Muon_Eta,"Muon_Eta[Muon_N]/D");
t->Branch("Muon_Phi",Muon_Phi,"Muon_Phi[Muon_N]/D");
t->Branch("Muon_Px",Muon_Px,"Muon_Px[Muon_N]/D");
t->Branch("Muon_Py",Muon_Py,"Muon_Py[Muon_N]/D");
t->Branch("Muon_Pz",Muon_Pz,"Muon_Pz[Muon_N]/D");
t->Branch("Muon_E",Muon_E,"Muon_E[Muon_N]/D");
t->Branch("Muon_Pt",Muon_Pt,"Muon_Pt[Muon_N]/D");
t->Branch("Muon_isem",Muon_isem,"Muon_isem[Muon_N]/D");
t->Branch("Muon_charge",Muon_charge,"Muon_charge[Muon_N]/D");
t->Branch("Muon_siso",Muon_siso,"Muon_siso[Muon_N]/D");
//taus
t->Branch("Tau_Eta",Tau_Eta,"Tau_Eta[Tau_N]/D");
t->Branch("Tau_Phi",Tau_Phi,"Tau_Phi[Tau_N]/D");
t->Branch("Tau_Px",Tau_Px,"Tau_Px[Tau_N]/D");
t->Branch("Tau_Py",Tau_Py,"Tau_Py[Tau_N]/D");
t->Branch("Tau_Pz",Tau_Pz,"Tau_Pz[Tau_N]/D");
t->Branch("Tau_E",Tau_E,"Tau_E[Tau_N]/D");
t->Branch("Tau_Pt",Tau_Pt,"Tau_Pt[Tau_N]/D");
t->Branch("Tau_isem",Tau_isem,"Tau_isem[Tau_N]/D");
t->Branch("Tau_traN",Tau_traN,"Tau_traN[Tau_N]/D");

//Missing energy
t->Branch("Miss_Phi",&Miss_Phi,"Miss_phi/D");
t->Branch("Miss_Px",&Miss_Px,"Miss_Px/D");
t->Branch("Miss_Py",&Miss_Py,"Miss_Py/D");
t->Branch("Miss_E",&Miss_E,"Miss_E/D");



while (1) {
  if(k==1 && Event_N>=2 ||!in.good()){  
  t->Fill();
       Jet_N=Ele_N=Muon_N=Tau_N=Photon_N=0;
                                                        }

if (!in.good()) break;

std::string line;
     
getline (in, line);

if (line.find("#") != line.npos||line.find_first_of ("0123456789") == line.npos)continue; 
                
//if (line.find_first_of ("0123456789") == line.npos) {
 //  continue;
 // }

std::istringstream input_line;
input_line.str (line);
input_line >> idx;
if (idx == 0) {
input_line >>Event_N;
input_line >>Trigger;
 k=1;
 continue;                  }

// reseting the k value
    k=0;

    input_line >> ty;
    input_line >> eta;
    input_line >> phi;
    input_line >> pt;
    input_line >> m; // invariant mass for jets
    input_line >> nt; // if jet, or tau is # tracks, otherwise charge for leptons
    input_line >> bt; // 0.0, 1.0 or 2.0 btag, or special muon isolation info
  // 
    input_line >> em;
    input_line >> d1;
    input_line >> d2;

    

switch(ty){
            case 0:  //photons
             Photon_Eta[Photon_N]=eta;
             Photon_Phi[Photon_N]=phi;
             Photon_Px[Photon_N] =pt*cos(phi);
             Photon_Py[Photon_N] =pt*sin(phi);
             Photon_Pz[Photon_N] =pt*sinh(eta);
             Photon_E[Photon_N]  =pt*cosh(eta);
             Photon_Pt[Photon_N] =pt;
             Photon_isem[Photon_N]=em;
             Photon_N++;
	     break;

            case 1:  // electrons
	     Ele_Eta[Ele_N]= eta;
             Ele_Phi[Ele_N]= phi;
	     Ele_Px[Ele_N] = pt*cos(phi);
             Ele_Py[Ele_N] = pt*sin(phi);
             Ele_Pz[Ele_N] = pt*sinh(eta);
             Ele_E[Ele_N]  = pt*cosh(eta);
	     Ele_Pt[Ele_N] = pt;
             Ele_isem[Ele_N]=em;
             Ele_charge[Ele_N]=nt;
	     Ele_N++;
	    break;

	   case 2: // muons
	     Muon_Eta[Muon_N]=eta;
	     Muon_Phi[Muon_N]=phi;
             Muon_Px[Muon_N] = pt*cos(phi);
             Muon_Py[Muon_N] = pt*sin(phi);
             Muon_Pz[Muon_N] = pt*sinh(eta);
             Muon_E[Muon_N]  = pt*cosh(eta);
	     Muon_Pt[Muon_N]=pt;
             Muon_isem[Muon_N]=em;
             Muon_charge[Muon_N]=nt;
             Muon_siso[Muon_N]=bt;
             Muon_N++;
	     break;

	   case 3:  //taus
	     Tau_Eta[Tau_N]=eta;
	     Tau_Phi[Tau_N]=phi;
             Tau_Px[Tau_N] = pt*cos(phi);
             Tau_Py[Tau_N] = pt*sin(phi);
             Tau_Pz[Tau_N] = pt*sinh(eta);
             Tau_E[Tau_N]  = pt*cosh(eta);
             Tau_Pt[Tau_N]=pt;
             Tau_isem[Tau_N]=em;
             Tau_traN[Tau_N]=nt;
      	     Tau_N++;

	     break;

           case 4:   //jets
	     Jet_Eta[Jet_N]=eta;
	     Jet_Phi[Jet_N]=phi;
             Jet_Px[Jet_N] = pt*cos(phi);
             Jet_Py[Jet_N] = pt*sin(phi);
             Jet_Pz[Jet_N] = pt*sinh(eta);
             Jet_E[Jet_N]  = sqrt(pt*cosh(eta)*pt*cosh(eta)+m*m);
             Jet_Pt[Jet_N]=pt;
             Jet_m[Jet_N]=m;
             Jet_isem[Jet_N]=em;
             Jet_traN[Jet_N]=nt;
             Jet_b[Jet_N]=(int)bt;             
	     Jet_N++;
	     break;
	   
	   case 6:    //missing energy
             Miss_Phi=phi;
             Miss_Px=pt*cos(phi);
             Miss_Py=pt*sin(phi);
             Miss_E=pt;
	     break;
	   default:
	       cout<< " no particle number found"<< ty<<endl;
	   	     break;
       }
 
}

cout <<"Total number of Event  "<<Event_N<<endl;
   in.close();
f->Write();
f->Close();
}