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

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 idx,ty,Trigger;


Int_t Ele_N=0,Jet_N=0,Muon_N=0,Tau_N=0,Photon_N=0;

Double_t Miss_Phi,Miss_Px,Miss_Py,Miss_E;
//you can change the range of the following arrays

vector<double> *Photon_Eta=0,*Photon_Phi=0,*Photon_Px=0,*Photon_Py=0,*Photon_Pz=0,*Photon_E=0,*Photon_Pt=0,*Photon_isem=0;

vector<double> *Ele_Eta=0,*Ele_Phi=0,*Ele_Px=0,*Ele_Py=0,*Ele_Pz=0,*Ele_E=0,*Ele_Pt=0,*Ele_isem=0;
vector<int> *Ele_charge=0;
vector<double> *Muon_Eta=0,*Muon_Phi=0,*Muon_Px=0,*Muon_Py=0,*Muon_Pz=0,*Muon_E=0,*Muon_Pt=0,*Muon_isem=0,*Muon_siso=0;
vector<int> *Muon_charge=0;
vector<double> *Tau_Eta=0,*Tau_Phi=0,*Tau_Px=0,*Tau_Py=0,*Tau_Pz=0,*Tau_E=0,*Tau_Pt=0,*Tau_isem=0;
vector<int> *Tau_traN=0;
vector<double> *Jet_Eta=0,*Jet_Phi=0,*Jet_Px=0,*Jet_Py=0,*Jet_Pz=0,*Jet_E=0,*Jet_Pt=0,*Jet_isem=0,*Jet_m=0;
vector<int> *Jet_b=0,*Jet_traN=0;
//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);
t->Branch("Photon_Phi",&Photon_Phi);
t->Branch("Photon_Px",&Photon_Px);
t->Branch("Photon_Py",&Photon_Py);
t->Branch("Photon_Pz",&Photon_Pz);
t->Branch("Photon_E",&Photon_E);
t->Branch("Photon_Pt",&Photon_Pt);
t->Branch("Photon_isem",&Photon_isem);

//jets
t->Branch("Jet_Eta",&Jet_Eta);
t->Branch("Jet_Phi",&Jet_Phi);
t->Branch("Jet_Px",&Jet_Px);
t->Branch("Jet_Py",&Jet_Py);
t->Branch("Jet_Pz",&Jet_Pz);
t->Branch("Jet_E",&Jet_E);
t->Branch("Jet_Pt",&Jet_Pt);
t->Branch("Jet_isem",&Jet_isem);
t->Branch("Jet_traN",&Jet_traN);
t->Branch("Jet_m",&Jet_m);
t->Branch("Jet_b",&Jet_b);//Jet tagging

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

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

//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");


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

(*Photon_Eta).clear();(*Photon_Phi).clear();(*Photon_Px).clear();(*Photon_Py).clear();(*Photon_Pz).clear();(*Photon_E).clear();(*Photon_Pt).clear();(*Photon_isem).clear();

(*Ele_Eta).clear();(*Ele_Phi).clear();(*Ele_Px).clear();(*Ele_Py).clear();(*Ele_Pz).clear();(*Ele_E).clear();(*Ele_Pt).clear();(*Ele_isem).clear();
(*Ele_charge).clear();
(*Muon_Eta).clear();(*Muon_Phi).clear();(*Muon_Px).clear();(*Muon_Py).clear();(*Muon_Pz).clear();(*Muon_E).clear();(*Muon_Pt).clear();(*Muon_isem).clear();
(*Muon_siso).clear();
(*Muon_charge).clear();
(*Tau_Eta).clear();(*Tau_Phi).clear();(*Tau_Px).clear();(*Tau_Py).clear();(*Tau_Pz).clear();(*Tau_E).clear();(*Tau_Pt).clear();(*Tau_isem).clear();
(*Tau_traN).clear();
(*Jet_Eta).clear();(*Jet_Phi).clear();(*Jet_Px).clear();(*Jet_Py).clear();(*Jet_Pz).clear();(*Jet_E).clear();(*Jet_Pt).clear();(*Jet_isem).clear();(*Jet_m).clear();
(*Jet_b).clear();(*Jet_traN).clear();

                                                        }

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;// particle type
    input_line >> eta;//psedurapidity
    input_line >> phi;//azmothalangle
    input_line >> pt;//Trnsverse momentum
    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;//some isolation parameters
    input_line >> d1; //Now it is dumy
    input_line >> d2; //Now it is dumy

    

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

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

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

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

             break;

           case 4:   //jets
            (*Jet_Eta).push_back(eta);
            (*Jet_Phi).push_back(phi);
            (*Jet_Px).push_back(pt*cos(phi));
            (*Jet_Py).push_back(pt*sin(phi));
            (*Jet_Pz).push_back(pt*sinh(eta));
            (*Jet_E).push_back(sqrt(pt*cosh(eta)*pt*cosh(eta)+m*m));
            (*Jet_Pt).push_back(pt);
            (*Jet_m).push_back(m);
            (*Jet_isem).push_back(em);
            (*Jet_traN).push_back((int)nt);
            (*Jet_b).push_back((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();
return 0;
}