source: JEM-EUSO/esaf_lal/branches/camille/camille_work/KIT_phase1_study/macros/Analysis.C @ 172

//
//  Analysis.C
//
//
//  Created by moretto on 29/05/13.
//
//

Int_t nb_entries = 0;

const char* inputfile="/Users/moretto/Documents/thesis/ESAF/Code/esaf_lal/esaf/camille_work/KIT_phase1_study/30_ns_TimeResolution__100_event/simu.root";
const char* inputfile2="/Users/moretto/Documents/thesis/ESAF/Code/esaf_lal/esaf/camille_work/KIT_phase1_study/10_ns_TimeResolution__100_event/simu.root";
const char* inputfile3="/Users/moretto/Documents/thesis/ESAF/Code/esaf_lal/esaf/camille_work/KIT_phase1_study/5_ns_TimeResolution__100_event/simu.root";
const char* inputfile4="/Users/moretto/Documents/thesis/ESAF/Code/esaf_lal/esaf/camille_work/KIT_phase1_study/0_ns_TimeResolution__100_event/simu.root";


EEvent*          ev = 0;
EDetector*       gDetector = NULL;
EDetPhoton*      gDetPhoton = NULL;
EBunchPhotons*   gBunchPhotons = NULL;

TProfile *hprof_multi[20];
//TProfile *hprof;
TH1F *histo_multi[100];
TCanvas *c3, *c4;
TH1F *histo_total;
TFile *f[20];
TTree *etree[20];

void gettree();
void init();
void process_profile();
Bool_t loadevent(Int_t i=0);

//______________________________________________________________________________
void Analysis()
{
    //Déclaration d'un tableau de TProfile permettant de stocker les TProfiles créé par l'analyse des fichiers
   
    Float_t x[200], y[200];
    Float_t bin1, bin2;
    const char hprof_name[50];
    
    //Initialisation & process du premier fichier
    init(inputfile, 0);
//    process_profile(0);
    
    sprintf(hprof_name, "hprof_multi%d", 0);
    hprof_multi[0] = new TProfile(hprof_name, "Average number of photons per GTU", 128, 0, 128);
    
    //f[0]->Close();
    //etree[0]->Delete();

    gDirectory->ls();
    
    c3 = new TCanvas("c3", "c3 - TProfile of the GTU distribution for 100 events for 30 ns dead time");
    //hprof_multi[0] = hprof;
    hprof_multi[0]->Print();
//    c3->cd();
//    hprof_multi[0]->Draw();
  
    //Initialisation & process du second fichier
    init(inputfile4, 1);
    //process_profile(1);
    
    sprintf(hprof_name, "hprof_multi%d", 1);
    hprof_multi[1] = new TProfile(hprof_name, "Average number of photons per GTU", 128, 0, 128);

    //f[1]->Close();
    //etree[1]->Delete();

    
    c4 = new TCanvas("c4", "c4 - TProfile of the GTU distribution for 100 events for 0 ns dead time");
    //hprof_multi[1] = hprof;
    hprof_multi[1]->Print();
    
    
    
    gDirectory->ls();
    
//    c4->cd();
//    hprof_multi[1]->Draw();
    
    
/*
    TCanvas *c5 = new TCanvas("c5", "Efficiency vs GTU");
  
    for (Int_t i=0; i<128; i++)
    {
        bin1 = hprof_multi[0]->GetBinContent(i);
        bin2 = hprof_multi[1]->GetBinContent(i);
        
        x[i] = i;
        
        if (bin2 == 0)
        {
            y[i] = 0;
        }
        
        else
        {
            y[i] = bin1/bin2;
        }
    }
    TGraph *g_efficiency = new TGraph(128, x, y);
    g_efficiency->SetLineColor(2);
    g_efficiency->SetLineWidth(2));
    g_efficiency->SetMarkerColor(4);
    g_efficiency->SetMarkerStyle(21);
    g_efficiency->Draw("ACP");*/
}

//______________________________________________________________________________
void process_profile(int n)
//ici on récupÚre les données de temps pour les 100 événements afin de réaliser un TProfile
{
    //Déclaration des histogrammes et autres
   // histo_total = new TH1F("histo_total", "Histogram of photons read by the electronics for 100 showers", 128, 0, 128);
    
    const char hprof_name[50];
    sprintf(hprof_name, "hprof_multi%d", n);
    hprof_multi[n] = new TProfile(hprof_name, "Average number of photons per GTU", 128, 0, 128);
    
    //histo_total->Reset();
    //hprof->Reset();
    
/*    //Boucle sur l'ensemble des événements pour créer une distribution totale
    for (Int_t  i=0; i<nb_entries ; i++)
    {
        loadevent(i);
        
        Int_t nb_photon = gDetector->GetNumPhotons();
        
        for (Int_t j=0; j<nb_photon; j++)
        {
            Int_t macrocell_status = gDetector->GetPhoton(j)->GetMacroCell();
            Int_t photon_type = gDetector->GetPhoton(j)->GetType();
            
            if (macrocell_status == 1 & photon_type != 2) //on ne sélectionne que les photons étant détectés par l'électronique & autre que les Cerenkov
            {
                Float_t gtu = gDetector->GetPhoton(j)->GetGtu();
                histo_total->Fill(gtu);
            }
            
        }
        
    }
    
     TCanvas *c1 = new TCanvas("c1", "Distribution totale");
     histo_total->GetXaxis()->SetTitle("GTU");
     histo_total->Draw(); */
    
    //Boucle sur l'ensemble des événements pour tracer séparément les histogrammes
    //TCanvas *c2 = new TCanvas("c2", "Collection of GTU histograms for 100 events");
    //c2->Divide(10,10);
    
    //TEST*******
    
 /*   for (Int_t i=0; i<nb_entries; i++)
    {
        
        const char histoname[50];
        sprintf(histoname,"histomulti%d",i);
        histo_multi[i] = new TH1F(histoname, "Single shower histograms", 128, 0, 128);
    }
    
    for (Int_t  i=0; i<100 ; i++)
    {
        loadevent(i);
        
        Int_t nb_photon = gDetector->GetNumPhotons();
        
        for (Int_t j=0; j<nb_photon; j++)
        {
            Int_t macrocell_status = gDetector->GetPhoton(j)->GetMacroCell();
            Int_t photon_type = gDetector->GetPhoton(j)->GetType();
            
            if (macrocell_status == 1 & photon_type != 2) //on ne sélectionne que les photons étant détectés par l'électronique & autre que les Cerenkov
            {
                Float_t gtu = gDetector->GetPhoton(j)->GetGtu();
                histo_multi[i]->Fill(gtu);
            }
        }
        
        //c2->cd(i+1);
        //histo_multi[i]->Draw();
        
    }
    
    //Boucle sur le tableau d'histogrammes précédent afin de réaliser un TProfile
    for (Int_t j=0; j<nb_entries; j++)
    {
        for (Int_t i=0; i<128; i++)
        {
            hprof_multi[n]->Fill(i, histo_multi[j]->GetBinContent(i));
        }
        
    }
    
    for (Int_t k=0; k<nb_entries; k++)
    {
        histo_multi[k]->Reset();
    }
    */
}

//______________________________________________________________________________
void init( const char* fname, int n_file)
{
    std::cout << "enter init #"<< n_file << std::endl;
    
    f[n_file] = new TFile(fname);
    gettree(n_file);
    std::cout << "exit init" << std::endl;
}

//______________________________________________________________________________
void gettree(int n_tree)
{
    std::cout << "enter gettree #" << n_tree << std::endl;
    
    etree[n_tree] = (TTree*)gDirectory->Get("etree");
    if ( etree[n_tree] )
    {
        nb_entries = etree[n_tree]->GetEntries();
        Printf("etree found with %d events stored.", nb_entries);
    }
    
    std::cout << "exit gettree" << std::endl;

}

//______________________________________________________________________________
Bool_t loadevent( Int_t i)
{
    TTree *etree = (TTree*)gDirectory->Get("etree");
    
    if ( !etree )
    {
        Printf("init(): unable to retrieve etree from TFile. Exiting");
        return kFALSE;
    }
    
    // associate the tree and the event
    if ( !ev )
    {
        ev = new EEvent();
        ev->SetBranches(etree);
    }
    
    etree->GetEntry(i);
    
    EDetector *detector = ev->GetDetector();
    
    gDetector = ev->GetDetector();
    
    return kTRUE;
}