/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/analyse/Renaud/analyze_noise.cpp

Go to the documentation of this file.

// compile with:
// gcc `root-config --cflags` `root-config --glibs` analyze_noise.cpp -o analyze_noise
/////////////////////////////////////////////////////////////////////////
// The first file contian noise from pedestal on the square meter
// The second contains threshold for each chip

#include <map>
#include "TKey.h"
#include <TROOT.h>
#include <TStyle.h>
#include <TRint.h>
#include <TKey.h>
#include <TTree.h>
#include <TCanvas.h>
#include "TH1.h"
#include "TF1.h"
#include <TH1I.h>
#include <TH2I.h>
#include <TFile.h>
#include <stdlib.h>
#include <TSystem.h>
#include <iostream>
#include "TApplication.h"
#include <sstream>
//#include "Log.hh"
#include <Rtypes.h>
#include <TCanvas.h>
#include "TColor.h"
#include "TFunction.h"
#include "TAttLine.h"
#include "TPaveStats.h"
//#include "MicroException.hh"
#include <string>
#include "Riostream.h"

using namespace std;


int main(int argc, char**argv)
//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);
        
        if (argc !=4)
        {
                cout << "usage: " << argv[0] << " file_scurve_noise file_offset_correction file_threshold " << endl ;
                exit(-1) ;
        }

        TString noise_filename_arg = argv[1] ;
        TString offset_filename_arg = argv[2] ;
        TString threshold_filename_arg = argv[3] ;
        
        const TString directory = "/gpfs/LAPP-DATA/LC/Detecteurs/MicroMegas/data/MICROROC/MR1/TEST_NOISE/";
        const TString noise_filename = directory + noise_filename_arg ;//Form("%s%s", directory, noise_filename_arg) ;
        const TString offset_filename = directory + offset_filename_arg ;
        const TString threshold_filename = directory + threshold_filename_arg ;//Form("%s%s", directory, threshold_filename_arg) ;

        cout << directory << endl ;
        
        const Int_t NbOfChip = 48 ;
        const Int_t NbOfChannels = 64 ;
        const Double_t thr_conv_ratio = 0.14 ; // fC / thrDAC
        const Double_t off_conv_ratio = 1.66 ; // thrDAC / off  /// = 0.602 offDAC / thrDAC
        TApplication theApp("App", &argc, argv);                                        // see $ROOTSYS/test/hworld.cxx
        //TApplication *theApp  = NULL;                         // from Jean
        //theApp  = new TRint("App",NULL,NULL );        // from Jean
        
//      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 ;
//      }
        ////////////////////////////////////////////////////////////////////////////////////////
        //          REMAINDER
        ////////////////////////////////////////////////////////////////////////////////////////
        // CONV ration : 0.14 fC / thrDACunit
        // DAC ratio : 1.92 THRDAC / OFFSET DAC
        ////////////////////////////////////////////////////////////////////////////////////////
        //          READ FIRST and SECOND FILE (pedestal)
        ////////////////////////////////////////////////////////////////////////////////////////

        ifstream file_noise, file_offset ;
        // data
        file_noise.open(noise_filename.Data()) ;
        if (!file_noise.good())
        {       cout << "Error opening" << noise_filename.Data() << endl ;
        }
        // offset
        file_offset.open(offset_filename.Data()) ;
        if (!file_offset.good())
        {       cout << "Error opening" << offset_filename.Data() << endl ;
        }
        // vars to read file
        Double_t chip, channel, crapoffset, pedestal_inflex, pedestal_inflex_err, pedestal_noise, pedestal_noise_err, offset ; // to read text file     
        Double_t noise_data_corr[NbOfChip][NbOfChannels]; // with offset corretion
        Double_t noise_data[NbOfChip][NbOfChannels];
        for (Int_t ichip=0;ichip<NbOfChip;ichip++)
        {       for (Int_t ichan=0;ichan<NbOfChannels;ichan++)
                {       if (!file_noise.good()) break;
                        if (!file_offset.good()) break;
                        file_noise >> chip >> channel >> crapoffset >> pedestal_inflex >> pedestal_inflex_err >> pedestal_noise >> pedestal_noise_err ;
                        file_offset >> chip >> channel >> offset ;
                        noise_data_corr[ichip][ichan] = pedestal_inflex - offset*off_conv_ratio ;
                        noise_data[ichip][ichan] = pedestal_inflex + offset*off_conv_ratio ;
                        //cout << pedestal_inflex << endl ;
                }
        }
        file_noise.close() ;
        file_offset.close() ;
        
        ////////////////////////////////////////////////////////////////////////////////////////
        //          READ SECOND and third FILE
        ////////////////////////////////////////////////////////////////////////////////////////
        ifstream file_threshold ;
        file_threshold.open(threshold_filename.Data()) ;
        if (!file_threshold.good())
        {       cout << "Error opening" << threshold_filename.Data() << endl ;
        }
        Double_t threshold ;
        Double_t threshold_data[NbOfChip] ;
        for (Int_t ichip=0;ichip<NbOfChip;ichip++)
        {       if (!file_threshold.good()) break;
                file_threshold >> chip >> threshold ;
                threshold_data[ichip] = threshold ;
        }
        file_offset.close() ;
        
        ////////////////////////////////////////////////////////////////////////////////////////
        //          Threshold difference
        ////////////////////////////////////////////////////////////////////////////////////////
        
        TH1F * h_thr = new TH1F ("h_thr", "+0", 100, 0, 10) ;
        h_thr->SetXTitle("Threshold [fC]");
        h_thr->SetYTitle("count");
        
        TH1F * h_thr2 = new TH1F ("h_thr2", "+3", 100, 0, 10) ;
        h_thr2->SetXTitle("Threshold [fC]");
        h_thr2->SetYTitle("count");
        
        TH1F * h_thr3 = new TH1F ("h_thr3", "without offset compensation", 100, -5, 5) ;
        h_thr3->SetXTitle("Threshold [fC]");
        h_thr3->SetYTitle("count");
        
        for (Int_t ichip=0;ichip<NbOfChip;ichip++)
        {       for (Int_t ichan=0;ichan<NbOfChannels;ichan++)
                {       h_thr->Fill((threshold_data[ichip] - noise_data_corr[ichip][ichan])*thr_conv_ratio) ;
                        h_thr2->Fill((threshold_data[ichip] - noise_data_corr[ichip][ichan]+3)*thr_conv_ratio) ;
                        h_thr3->Fill((threshold_data[ichip] - noise_data[ichip][ichan]+3)*thr_conv_ratio) ;
                }
        }
        TCanvas * c1 = new TCanvas("c1","");
        h_thr->Draw() ;
        
        TCanvas * c2 = new TCanvas("c2","");
        c2->cd() ;
        h_thr2->Draw() ;
        
        TCanvas * c3 = new TCanvas("c3","");
        c3->cd() ;
        h_thr3->Draw() ;        
        
//      ////////////////////////////////////////////////////////////////////////////////////////
//      
//      
//      
//      TCanvas * c1 = new TCanvas("c1","MICROROC gain");
//      h_gain->SetLineColor(kBlue+1);
//      h_gain->Draw("");
//      h_gain->Fit("gaus","RQ", "SAME", 0.13 , 0.15);
//      h_gain->GetFunction("gaus")->SetLineColor(kRed);
//      h_gain->GetXaxis()->SetTitle("Conversion ratio [fCV/DACu]");
//      h_gain->GetYaxis()->SetTitle("Count");
//      
//      
//      ////////////////////////////////////////////////////////////////////////////////////////
//      TCanvas * c2 = new TCanvas("c2","MICROROC data and pedestal");
//      c2->cd() ;

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

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

//      c2->Update(); // to create TGraph !!! COMPULSORY !!

//      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+1);
//      p1->SetX1NDC(0.75);
//      p1->SetY1NDC(0.8);
//      p1->SetY2NDC(0.9);
//      p1->Draw();


//      // NEED SAMES (!=SAME) in Drawin histo !!!!! http://root.cern.ch/root/html/THistPainter.html#THistPainter:Paint find sames in text
//      //h_data->GetListOfFunctions()->Print();
//      TPaveStats * p2 = (TPaveStats*) h_data->GetListOfFunctions()->FindObject("stats");
//      p2->Print();
//      h_data->GetListOfFunctions()->Remove(p2);
//      h_data->SetStats(0);
//      p2->SetTextColor(kOrange+5);
//      p2->SetX1NDC(0.75);
//      p2->SetX2NDC(0.9);
//      p2->SetY1NDC(0.7);
//      p2->SetY2NDC(0.8);
//      p2->Draw();



        theApp.Run(kTRUE) ;
        //theApp->Run();
        //delete theApp;
        return 0 ;

}

---