# Example of analysis code with Chains

    {
    ///////////////////////////////////////////////////////////////////////////////
    //   This macro illustrates how to loop on events in a chain of files
    //   containing a TTree object
    //   The skeleton of this file has been automatically generated
    //     (Wed Jul 23 14:09:39 1997 by ROOT version 1.01/07)
    //   from TTree h3333/ATLFAST
    //   found on file: atlfast_whbb_lowlum_r04.root
    //
    //   The analysis module and the data sets have been kindly provided
    //   by the ATLAS Atlfast team.
    //
    //   The complete source of this macro, associated macros and files
    //   can be found at  AtlFast massbb
    ////////////////////////////////////////////////////////////////////////////////

    //Reset ROOT
       gROOT->Reset();

    //We intend to use this macro for benchmarking ROOT
       gBenchmark->Start("massbb");

    //Load some utility functions and the event analysis code
       gROOT->LoadMacro("ElaUtil.C");
       gROOT->LoadMacro("ElaAnal.C");

    // histos initialization. Create file and result histograms
       TFile histofile("atlf_massbb.root","RECREATE","WH-->bb mass distribution");
       TH1F Mbb_cru("Mbb_cru","m_bb_cru (GeV)",50,0,150);
       TH1F Ptj_cru("Ptj_cru","p_T^jet_cru (GeV)",50,0,100);
       TH1F Mbb("Mbb","m_bb (GeV)",50,0,150);
       TH1F Ptj("Ptj","p_T^jet (GeV)",50,0,100);

    // Connecting calibration file
       TFile calibfile("atlf_calibration.root");
    // Get histogram Kfac from file. We directly create a pointer
    // because we intend to use this histogram when the current directory
    // is not calibfile itself
       TH1F *Kfac = (TH1F*)calibfile.Get("Kfac");

    // Create a chain of files. The parameter to the TChain constructor
    // is the name of the Tree to be processed in each file of the chain.
       TChain chain("h3333");
       chain.Add("atlfast_whbb_lowlum_r04.root");
       chain.Add("atlfast_whbb_lowlum_r04.root");  // <== add a new file

    //Declaration of leaves types
       UInt_t          Jrun;
       UInt_t          Jevnt;
       UInt_t          Jflag;
       UInt_t          Isub;
       UInt_t          Nel;
       UInt_t          Nmu;
       UInt_t          Nmux;
       UInt_t          Nph;
       UInt_t          Jetb;
       UInt_t          Jetc;
       UInt_t          Jetl;
       Float_t         Pmiss[2];
       UInt_t          Nlep;
       UInt_t          Kflep[12];
       Float_t         Pxlep[12];
       Float_t         Pylep[12];
       Float_t         Pzlep[12];
       Float_t         Eelep[12];
       UInt_t          Npho;
       UInt_t          Kfpho[12];
       Float_t         Pxpho[12];
       Float_t         Pypho[12];
       Float_t         Pzpho[12];
       Float_t         Eepho[12];
       UInt_t          Njeta;
       UInt_t          Kfjet[20];
       Float_t         Pxjet[20];
       Float_t         Pyjet[20];
       Float_t         Pzjet[20];
       Float_t         Eejet[20];
       UInt_t          Nonmux;
       UInt_t          Kfmux[12];
       Float_t         Pxmux[12];
       Float_t         Pymux[12];
       Float_t         Pzmux[12];
       Float_t         Eemux[12];
       UInt_t          Npart;
       UInt_t          Kfpar[40];
       Float_t         Pxpar[40];
       Float_t         Pypar[40];
       Float_t         Pzpar[40];
       Float_t         Eepar[40];
       Float_t         Tgall;
       Float_t         Tgem1;
       Float_t         Tgph1;
       Float_t         Tgem2;
       Float_t         Tgmu1;
       Float_t         Tgmu2;
       Float_t         Tgemu;
       Float_t         Tgjt1;
       Float_t         Tgjt3;
       Float_t         Tgjt4;
       UInt_t          Ntra;
       UInt_t          Kftra[100];
       Float_t         Pxtra[100];
       Float_t         Pytra[100];
       Float_t         Pztra[100];
       Float_t         Eetra[100];

    //Set branch addresses
       chain.SetBranchAddress("Jrun",&Jrun);
       chain.SetBranchAddress("Jevnt",&Jevnt);
       chain.SetBranchAddress("Jflag",&Jflag);
       chain.SetBranchAddress("Isub",&Isub);
       chain.SetBranchAddress("Nel",&Nel);
       chain.SetBranchAddress("Nmu",&Nmu);
       chain.SetBranchAddress("Nmux",&Nmux);
       chain.SetBranchAddress("Nph",&Nph);
       chain.SetBranchAddress("Jetb",&Jetb);
       chain.SetBranchAddress("Jetc",&Jetc);
       chain.SetBranchAddress("Jetl",&Jetl);
       chain.SetBranchAddress("Pmiss",Pmiss);
       chain.SetBranchAddress("Nlep",&Nlep);
       chain.SetBranchAddress("Kflep",Kflep);
       chain.SetBranchAddress("Pxlep",Pxlep);
       chain.SetBranchAddress("Pylep",Pylep);
       chain.SetBranchAddress("Pzlep",Pzlep);
       chain.SetBranchAddress("Eelep",Eelep);
       chain.SetBranchAddress("Npho",&Npho);
       chain.SetBranchAddress("Kfpho",Kfpho);
       chain.SetBranchAddress("Pxpho",Pxpho);
       chain.SetBranchAddress("Pypho",Pypho);
       chain.SetBranchAddress("Pzpho",Pzpho);
       chain.SetBranchAddress("Eepho",Eepho);
       chain.SetBranchAddress("Njeta",&Njeta);
       chain.SetBranchAddress("Kfjet",Kfjet);
       chain.SetBranchAddress("Pxjet",Pxjet);
       chain.SetBranchAddress("Pyjet",Pyjet);
       chain.SetBranchAddress("Pzjet",Pzjet);
       chain.SetBranchAddress("Eejet",Eejet);
       chain.SetBranchAddress("Nonmux",&Nonmux);
       chain.SetBranchAddress("Kfmux",Kfmux);
       chain.SetBranchAddress("Pxmux",Pxmux);
       chain.SetBranchAddress("Pymux",Pymux);
       chain.SetBranchAddress("Pzmux",Pzmux);
       chain.SetBranchAddress("Eemux",Eemux);
       chain.SetBranchAddress("Npart",&Npart);
       chain.SetBranchAddress("Kfpar",Kfpar);
       chain.SetBranchAddress("Pxpar",Pxpar);
       chain.SetBranchAddress("Pypar",Pypar);
       chain.SetBranchAddress("Pzpar",Pzpar);
       chain.SetBranchAddress("Eepar",Eepar);
       chain.SetBranchAddress("Tgall",&Tgall);
       chain.SetBranchAddress("Tgem1",&Tgem1);
       chain.SetBranchAddress("Tgph1",&Tgph1);
       chain.SetBranchAddress("Tgem2",&Tgem2);
       chain.SetBranchAddress("Tgmu1",&Tgmu1);
       chain.SetBranchAddress("Tgmu2",&Tgmu2);
       chain.SetBranchAddress("Tgemu",&Tgemu);
       chain.SetBranchAddress("Tgjt1",&Tgjt1);
       chain.SetBranchAddress("Tgjt3",&Tgjt3);
       chain.SetBranchAddress("Tgjt4",&Tgjt4);
       chain.SetBranchAddress("Ntra",&Ntra);
       chain.SetBranchAddress("Kftra",Kftra);
       chain.SetBranchAddress("Pxtra",Pxtra);
       chain.SetBranchAddress("Pytra",Pytra);
       chain.SetBranchAddress("Pztra",Pztra);
       chain.SetBranchAddress("Eetra",Eetra);

    //     This is the loop skeleton
    //       To read only selected branches, Insert statements like:
    // chain.SetBranchStatus("*",0);  // disable all branches
    // chain.SetBranchStatus("branchname",1);  // activate branchname

    //  Invoke analysis code
       ElaAnal();

    //..... save histograms

       histofile.Write();
       histofile.Close();

       gBenchmark->Show("massbb");
       Float_t hp735     = 27;  //this macro gives 27 RootMarks on an HP735
       Float_t massbb_rt = gBenchmark->GetRealTime("massbb");
       Float_t massbb_ct = gBenchmark->GetCpuTime("massbb");
       Float_t rtmark    = hp735*(439/massbb_rt);
       Float_t cpmark    = hp735*(434/massbb_ct);
       printf("massbb    = %7.2f RealMARKS,  = %7.2f CpuMARKS\n",rtmark,cpmark);
       Float_t rtmarks   = 0.5*(rtmark+cpmark); // take average of realtime and cputime
       printf("\n");
       printf("****************************************************\n");
       printf("* Your machine is estimated at %7.2f ROOTMARKS   *\n",rtmarks);
       printf("****************************************************\n");
    }