/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/analyse/Renaud/ROOT/analyze_prod.C

Go to the documentation of this file.

//#include "Riostream.h"
// launch with .x analyze_prod.C (1)

analyze_prod(const Int_t prod)
{       
        gROOT->Reset();

//      gROOT->SetStyle("Plain");
        gStyle->SetFrameFillStyle(0);
        gStyle->SetPalette(1);
        gStyle->SetOptStat(111111);
        gStyle->SetFrameFillStyle(0);
        gStyle->SetOptStat("");
        gStyle->SetOptFit(0111);
        gStyle->SetStatX(0.9);
        gStyle->SetStatY(0.9);
        gStyle->SetStatH(0.1);
        gStyle->SetStatW(0.1);

//      gStyle->SetOptStat("") ;
//      gStyle->SetOptFit(0000);        
        
        gStyle->SetOptStat("");
        gStyle->SetOptFit(10001);
        
        const Int_t NbOfChannels = 64 ;
        
        const TString directory = Form("/gpfs/LAPP-DATA/LC/Detecteurs/MicroMegas/data/MICROROC/PROD_%d/RESULTS/", prod);
        cout << directory << endl ;
        switch (prod)
        {       case 1:
                        Int_t start = 1 ;
                        //Int_t stop = 341 ;
                        Int_t stop = 30 ;
                        break ;
                case 2:
                        Int_t start = 342 ;
                        Int_t stop = 1136 ;
                        break ;
                default:
                        cout << "This production run does not exist yet !" << endl ;
                        exit(-1) ;
        }
        
        
//      for (Int_t chip=start;chip<=stop;chip++)
//      {       
//              const TString name_file_gain = directory +  Form("chip_%d_gain_OK.txt", chip) ;
//              const TString name_file_gain = Form("%schip_%d_gain_OK.txt", directory, chip) ;
//              cout << name_file_gain << endl ;
//      }
        
        // Variable definition
        Double_t n, gain ;      // to read text file
        Double_t pedestal_inflex, pedestal_inflex_err, pedestal_noise, pedestal_noise_err ; // to read text file
        Double_t data_inflex, data_inflex_err, data_noise, data_noise_err ;     // to read text file
        TH1F * h_gain = new TH1F ("h_gain", "",100, 0.12, 0.16) ; // histo to store result
        h_gain->SetXTitle("");
        TH1F * h_ped = new TH1F ("h_ped", "", 1024, 0, 1024) ;
        h_ped->SetXTitle("[DACu]");
        TH1F * h_data = new TH1F ("h_data", "", 1024, 0, 1024) ;
        h_data->SetXTitle("[DACu]");
        ifstream file_gain, file_data, file_pedestal ;
        for (Int_t chip=start;chip<=stop;chip++)
        {       const TString name_file_gain = directory + Form("chip_%d_gain_OK.txt", chip) ;
                file_gain.open(name_file_gain.Data()) ;
                if (!file_gain.good())
                {       cout << "Chip " << chip << " has been rejected during test" << endl ;
                        //TString name_file = Form("chip_%d_gain_BAD.txt", chip) ;
                        //if (!fp.good()) cout << "Error opening " << name_file << endl ;
                        //break ;
                }
                else
                {       const TString name_file_pedestal = directory + Form("chip_%d_pedestal.txt", chip) ;
                        file_pedestal.open(name_file_pedestal.Data()) ;
                        const TString name_file_data = directory + Form("chip_%d_data.txt", chip) ;
                        file_data.open(name_file_data.Data()) ;
                        for (Int_t ch=0;ch<NbOfChannels;ch++)
                        {       file_gain >> gain ;
                                if (!file_gain.good()) break;
                                file_pedestal >> n >> pedestal_inflex >> pedestal_inflex_err >> pedestal_noise >> pedestal_noise_err ;
                                file_data >> n >> data_inflex >> data_inflex_err >> data_noise >> data_noise_err ;
                                h_gain->Fill(gain) ;
                                h_ped->Fill(pedestal_inflex) ;
                                h_data->Fill(data_inflex) ;
                        }
                }
                file_gain.close();      
                file_pedestal.close();  
                file_data.close();      
                
                
        }
        
        TCanvas * c1 = new TCanvas("c1","MICROROC gain");
        h_gain->SetLineColor(kBlue+1);
        h_gain->Draw();
        h_gain->Fit("gaus","R", "SAME", 0.13 , 0.15);
        h_gain->GetFunction("gaus")->SetLineColor(kRed);
        h_gain->GetXaxis()->SetTitle("Gain [V/fC]");
        
        TCanvas * c2 = new TCanvas("c2","MICROROC pedestal");
        c2->cd() ;

        h_ped->Draw();
        h_ped->SetLineColor(kBlue+1);
        h_ped->Fit("gaus","R", "SAME", 160, 210);
        h_ped->GetFunction("gaus")->SetLineColor(kBlue+8);

        h_data->Draw("SAMES");
        h_data->SetLineColor(kGreen+1);
        h_data->Fit("gaus","R", "SAME", 500, 580);
        h_data->GetFunction("gaus")->SetLineColor(kGreen+5);

        c1->Update();

        const TPaveStats *p1 = (TPaveStats*) h_ped->GetListOfFunctions()->FindObject("stats");
        h_ped->GetListOfFunctions()->Print();
//      p1->Print();
//      h_ped->GetListOfFunctions()->Remove(p1);
        h_ped->SetStats(0);
        p1->SetTextColor(kBlue+8);
        p1->SetX1NDC(0.75);
        p1->SetY1NDC(0.8);
        p1->SetY2NDC(0.9);
        p1->Draw();


        // NEED SAMES (!=SAME) in Drawin histo !!!!!
        //h_data->GetListOfFunctions()->Print();
        const TPaveStats *p2 = (TPaveStats*) h_data->GetListOfFunctions()->FindObject("stats");
        p2->Print();
        h_data->GetListOfFunctions()->Remove(p2);
        h_data->SetStats(0);
        p2->SetTextColor(kGreen+5);
        p2->SetX1NDC(0.75);
        p2->SetX2NDC(0.9);
        p2->SetY1NDC(0.7);
        p2->SetY2NDC(0.8);
        p2->Draw();



        
//      TCanvas * c3 = new TCanvas("c3","MICROROC data");
//      c3->cd() ;
//      h_data->Draw();
//      
//      const Int_t NbOfRun = 5 ; // x axis: temperature
//      const Int_t NbOfPoints = 16 ; // pied: 0 to 15
//      const Int_t NbOfChannels = 64 ;

//      Double_t n, a, b, c, d ;

//      ///////////////////////////
//      // Plot noise vs t
//      ///////////////////////////
//      Float_t temperature[]={25.5, 47.0, 68.5, 87.0, 105.0};
//      Double_t x[NbOfPoints];
//      for (Int_t i=0;i<NbOfPoints;i++)
//      {
//              x[i]=i ;
//      }
//      
//      Double_t data_inflex[NbOfChannels][NbOfRun][NbOfPoints] ; // first dim is for x / y
//      
//      Double_t mean_inflex[NbOfRun][NbOfPoints] ;
//      // Gather y data from files
//      for (Int_t run=0;run<NbOfRun;run++) // x axis
//      {       for (Int_t ped=0;ped<NbOfPoints;ped++)
//              {
//                      mean_inflex [run][ped] = 0 ;
//                      TString name_file = directory + "run" + Form("%d", 2*run+1) + "_pied" + Form("%d", ped) + ".txt" ;
//                      cout << name_file << endl ;
//                      ifstream fp ;
//                      fp.open(name_file.Data()) ; 
//              
//                      if (!fp.good()) cout << "pb !";
//                      for (Int_t ch=0;ch<NbOfChannels;ch++)
//                      {               fp >> n >> a >> b >> c >> d ;
//                                      //cout << n << " " << a << " " << b << " " << c << " " << d <<  endl ;
//                                      if (!fp.good()) break;
//                                      // fill data
//                                      data_inflex [ch][run][ped] = a ; // DAC units 
//                                      // fill mean for all channels
//                                      mean_inflex [run][ped] += data_inflex [ch][run][ped] ;
//                      }
//                      fp.close();     
//                      mean_inflex [run][ped] /= NbOfChannels ;
//              }
//      }
//      
////    cout << "Temperature" ;
////    for (Int_t run=0;run<NbOfPoints;run++) // x axis
////    {       cout << "\t" << temperature[run] ;
////    }
////    cout << endl << "Offset" << "\t" ;
////    for (Int_t run=0;run<NbOfPoints;run++) // x axis
////    {       cout << "\t" << data_noise[1][run] ;
////    }
////    cout << endl ;
//      
////    exit(-1);
//      
//      //----------------------------------------------------------------
//      //                       BUILD GRAPH 
//      //----------------------------------------------------------------      
//      TCanvas * c1 = new TCanvas("c1","MICROROC offset dac");
//      TMultiGraph * mg = new TMultiGraph("mg","");
//      TGraph * gr[NbOfChannels];
//      for(Int_t igraph=0;igraph<NbOfRun;igraph++)     // one graph per temperature
//      {       gr [igraph] = new TGraph(NbOfPoints, x, mean_inflex [igraph] ); // TGraph (n, x, y)
//              gr [igraph]->SetLineColor(kBlue+igraph) ;
//              gr [igraph]->SetLineWidth(1);
//              gr [igraph]->SetMarkerColor(kBlue+igraph);
//              gr [igraph]->SetMarkerStyle(8);
//              gr [igraph]->SetMarkerSize(1);
//              mg->Add(gr [igraph]);
//      }
//      
//      mg->Draw("ALP");
//      mg->GetXaxis()->SetTitle("Pedestal [DACu]");
//      mg->GetXaxis()->SetRangeUser(0.,110.);
//      mg->GetYaxis()->SetTitle("Inflexion Point [DACu]");
////    mg->GetYaxis()->SetRangeUser(2.4,2.5);
//      mg->GetYaxis()->SetTitleOffset(1.1);
//      mg->Draw("ALP"); // to refresh
////    Legend
////    TString temp_string = Form ("%f", x[1]) ;
////    temp_string 
//      TLegend * leg = new TLegend(0.1,0.75,0.25,0.9) ;
//      for(Int_t igraph=0;igraph<NbOfRun;igraph++)     // one graph per temperature
//      {       
//              TString temp_string = Form ("%5.1f #circC", temperature[igraph]) ;
//              leg->AddEntry(gr [igraph], temp_string, "lp");
//      }
//      leg->SetFillStyle(1);
//      leg->SetFillColor(0);
//      leg->Draw();
        
        return 0 ;

}

---