Example #1
0
void fitterLike2() {
  
  //Setting style
   labstyle();
   
   // Create the canvas
   TCanvas *c_histo = new TCanvas("c_histo","canvas histo",600,600);
   c_histo->cd();
   
   //Create the histogram
   TH1F *histo = new TH1F("histo","",100,-4.,4.);
   
   // Event generation (Double Gaussian)
   Int_t i=0;
   for(i=0;i<7000;++i){
     xvar[i]= randGen.Gaus(mA,sA);
     histo->Fill(xvar[i]);
  };
   
   for(i=7000;i<10000;++i){
     xvar[i]= randGen.Gaus(mB,sB);
     histo->Fill(xvar[i]);
   };
   
   // Draw the histogram
   histo->GetXaxis()->SetTitle("R [cm] "); // Let us assume a lenght on x axis
   histo->GetYaxis()->SetTitle("Events per 0.08 cm "); 
   histo->Draw();

   TFitter *fitter = new TFitter(PARAMETERS); //initialize TFitter with a maximum of 5 params
   fitter->SetDefaultFitter("Minuit"); // set minimizer. Default is Minuit.
   fitter->SetFCN(fcn); // set FCN

   // Set starting values and step sizes for parameters  
   Double_t vstart[PARAMETERS] = {0.3,  -1.  , 1.  , 0.5 , 0.5 };
   Double_t step[PARAMETERS]   = {0.0001, 0.0001, 0.0001, 0.0001, 0.0001};   //step 0 li rende costanti

   //Int_t SetParameter(Int_t ipar, const char* parname, Double_t value, Double_t verr, Double_t vlow, Double_t vhigh)
   fitter->SetParameter(0, "fA", vstart[0] , step[0], 0.,1.); // Bounded
   fitter->SetParameter(1, "mA", vstart[1] , step[1], 0.,0.);
   fitter->SetParameter(2, "mB", vstart[2] , step[2], 0.,0.);
   fitter->SetParameter(3, "sA", vstart[3] , step[3], 0.,0.);
   fitter->SetParameter(4, "sB", vstart[4] , step[4], 0.,0.);
   
   // Now ready for minimization step
   // Start minimization with arglist[0] max iterations and arglist[1] tolerance:
   // the default tolerance is 0.1, and the minimization will stop when
   // the estimated vertical distance to the minimum (EDM) is less than 
   // 0.001*[tolerance]*ERRDEF
   //Int_t ExecuteCommand(const char* command, Double_t* args, Int_t nargs)
   Double_t arglist[2] = {0.,0.1}; //
   fitter->ExecuteCommand("MIGRAD", arglist, 2);

   //arglist[0] = 0.;  
   //fitter->ExecuteCommand("HESSE", arglist, 1);
   //fitter->ExecuteCommand("MINOS", arglist, 1);

   //qui il metodo: https://root.cern.ch/root/html/TFitter.html#TFitter:GetStats
   Double_t fcnmin, edm, errdef;
   Int_t nvpar, nparx;
   fitter->GetStats(fcnmin, edm, errdef, nvpar, nparx);
   std::cout << "######### FIT INFO ################ " << std::endl;
   std::cout << "FCN(min) = " << fcnmin << endl; 
   std::cout << "EDM      = " << edm << endl; 
   std::cout << "ERRDEF   = " << errdef << endl;
   std::cout << "nvpar    = " << nvpar << endl;
   std::cout << "nparx    = " << nparx << endl;
   std::cout << "######### PARAMETERS ################ " << std::endl;
   std::cout << "fA = " << fitter->GetParameter(0) << "+/-" << fitter->GetParError(0) << std::endl;
   std::cout << "mA = " << fitter->GetParameter(1) << "+/-" << fitter->GetParError(1) << std::endl;
   std::cout << "sA = " << fitter->GetParameter(2) << "+/-" << fitter->GetParError(2) << std::endl;
   std::cout << "mB = " << fitter->GetParameter(3) << "+/-" << fitter->GetParError(3) << std::endl;
   std::cout << "sB = " << fitter->GetParameter(4) << "+/-" << fitter->GetParError(4) << std::endl;
   

   //Double_t GetCovarianceMatrixElement(Int_t i, Int_t j) const
   //std::cout << " prova del primo elemento della matrice = "<<fitter->GetCovarianceMatrixElement(0,0) << std::endl;

   std::cout << "######### COVARIANCE MATRIX ################ " << std::endl;
   // Write on .txt file covariance Matrix 
   FILE *file_cov = fopen ("_txt/covariance_matrix2.txt", "w");
   Int_t icol=0;
   Int_t irow=0;
   if (nvpar==1)
     {
       fprintf (file_cov, "%e \n", fitter->GetCovarianceMatrixElement(0,0)); 
       printf ("%e \n", fitter->GetCovarianceMatrixElement(0,0)); 
     }
   else
     {
       for (irow=0; irow<nvpar; irow++)
	 {
	   for (icol=0; icol<nvpar; icol++)
	     { 
               fprintf (file_cov, "%e ", fitter->GetCovarianceMatrixElement(irow,icol));
	       printf ("%e ", fitter->GetCovarianceMatrixElement(irow,icol));
	     };
	   fprintf (file_cov, "\n");
	   printf ("\n");
	 };
       //fprintf (file_cov, "\n");  
       //printf ("\n");  
     };
   fclose (file_cov);
   std::cout << "############################################ " << std::endl;
   
 //Projection
   TF1 *f_proj = new TF1("f_proj",pdf_proj,-4.,4.,5);
   
   // Sets values 
   for(Int_t k=0; k<PARAMETERS; k++){
     f_proj->SetParameter(k,fitter->GetParameter(k));
   };
   
   f_proj->Draw("SAME");

   c_histo->Print("./_fig/histo2.pdf");
   c_histo->Print("./_fig/histo2.eps");

}
Example #2
0
void fitterLike3() {

  // Setting per lo stile del canvas e del plot
  //gROOT->SetStyle("Plain");
  //gStyle->SetOptStat(0000000);
  //gStyle->SetOptFit(1111); //opt stat
  
  //Setting style
   labstyle();

   TCanvas *c_fun_tot = new TCanvas("c_fun_tot","canvas function",600,600);
   c_fun_tot->cd();
   //Create function
   TF2 *f_fun_tot = new TF2("f_fun_tot",pdf2D,x_min,x_max,y_min,y_max,9);
   f_fun_tot->SetParameter(0, fA) ;
   f_fun_tot->SetParameter(1,mAx) ;
   f_fun_tot->SetParameter(2,mAy) ;
   f_fun_tot->SetParameter(3,mBx) ;
   f_fun_tot->SetParameter(4,mBy) ;
   f_fun_tot->SetParameter(5,sAx) ;
   f_fun_tot->SetParameter(6,sAy) ;
   f_fun_tot->SetParameter(7,sBx) ;
   f_fun_tot->SetParameter(8,sBy) ;
   f_fun_tot->Draw("surf");
   std::cout << "Integral(fun_tot) = " << f_fun_tot->Integral(x_min,x_max,y_min,y_max) << std::endl; 

   TCanvas *c_fun_A = new TCanvas("c_fun_A","canvas function",600,600);
   c_fun_A->cd();
   TF2 *f_fun_A = new TF2("f_fun_A",pdf2D,x_min,x_max,y_min,y_max,9);
   f_fun_A->SetParameter(0, 1.) ;
   f_fun_A->SetParameter(1,mAx) ;
   f_fun_A->SetParameter(2,mAy) ;
   f_fun_A->SetParameter(3,mBx) ;
   f_fun_A->SetParameter(4,mBy) ;
   f_fun_A->SetParameter(5,sAx) ;
   f_fun_A->SetParameter(6,sAy) ;
   f_fun_A->SetParameter(7,sBx) ;
   f_fun_A->SetParameter(8,sBy) ;
   f_fun_A->Draw("surf");
   std::cout << "Integral(fun_A) = " << f_fun_A->Integral(x_min,x_max,y_min,y_max) << std::endl;

   TCanvas *c_fun_B = new TCanvas("c_fun_B","canvas function",600,600);
   c_fun_B->cd();
   TF2 *f_fun_B = new TF2("f_fun_B",pdf2D,x_min,x_max,y_min,y_max,9);
   f_fun_B->SetParameter(0, 0.) ;
   f_fun_B->SetParameter(1,mAx) ;
   f_fun_B->SetParameter(2,mAy) ;
   f_fun_B->SetParameter(3,mBx) ;
   f_fun_B->SetParameter(4,mBy) ;
   f_fun_B->SetParameter(5,sAx) ;
   f_fun_B->SetParameter(6,sAy) ;
   f_fun_B->SetParameter(7,sBx) ;
   f_fun_B->SetParameter(8,sBy) ;
   f_fun_B->Draw("surf");
   std::cout << "Integral(fun_B) = " << f_fun_B->Integral(x_min,x_max,y_min,y_max) << std::endl;
   
   //Double_t bin_width_x = (x_max-x_min)/bin_number_x;
   //Double_t bin_width_y = (y_max-y_min)/bin_number_y;
   
   //Create the histogramz
   TH2F *histo_tot = new TH2F("histo_tot","",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
   TH2F *histo_A   = new TH2F("histo_A"  ,"",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
   TH2F *histo_B   = new TH2F("histo_B"  ,"",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
 
   TH1F *histo_tot_x = new TH1F("histo_tot_x","",bin_number_x,x_min,x_max);
   TH1F *histo_tot_y = new TH1F("histo_tot_y","",bin_number_y,y_min,y_max);
   TH1F *histo_A_x = new TH1F("histo_A_x"    ,"",bin_number_x,x_min,x_max);
   TH1F *histo_A_y = new TH1F("histo_A_y"    ,"",bin_number_y,y_min,y_max);
   TH1F *histo_B_x = new TH1F("histo_B_x"    ,"",bin_number_x,x_min,x_max);
   TH1F *histo_B_y = new TH1F("histo_B_y"    ,"",bin_number_y,y_min,y_max);

   //proj
   TH2F *histo_proj_tot = new TH2F("histo_proj_tot","",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
   TH2F *histo_proj_A   = new TH2F("histo_proj_A"  ,"",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
   TH2F *histo_proj_B   = new TH2F("histo_proj_B"  ,"",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);

   TH1F *histo_proj_tot_x = new TH1F("histo_proj_tot_x","",s_proj*bin_number_x,x_min,x_max);
   TH1F *histo_proj_tot_y = new TH1F("histo_proj_tot_y","",s_proj*bin_number_y,y_min,y_max);
   TH1F *histo_proj_A_x = new TH1F("histo_proj_A_x"    ,"",s_proj*bin_number_x,x_min,x_max);
   TH1F *histo_proj_A_y = new TH1F("histo_proj_A_y"    ,"",s_proj*bin_number_y,y_min,y_max);
   TH1F *histo_proj_B_x = new TH1F("histo_proj_B_x"    ,"",s_proj*bin_number_x,x_min,x_max);
   TH1F *histo_proj_B_y = new TH1F("histo_proj_B_y"    ,"",s_proj*bin_number_y,y_min,y_max);
   

   // ################################################
   // ###### GENERATION ##############################
   // ################################################

   // Event generation (Double Gaussian)
   Int_t i=0;
   for(i=0;i<(Int_t) (MAX*fA);i++){
     xvar[i] = randGen.Gaus(mAx,sAx);
     yvar[i] = randGen.Gaus(mAy,sAy);
     histo_tot->Fill(xvar[i],yvar[i]);
     histo_tot_x->Fill(xvar[i]);
     histo_tot_y->Fill(yvar[i]);
     histo_A->Fill(xvar[i],yvar[i]);
     histo_A_x->Fill(xvar[i]);
     histo_A_y->Fill(yvar[i]);
     //std::cout << "i = " << i << " "<< xvar[i] << " "<< yvar[i] << std::endl; 
  };
   
   for(i=(Int_t) (MAX*fA);i<MAX;i++){
     xvar[i]= randGen.Gaus(mBx,sBx);
     yvar[i]= randGen.Gaus(mBy,sBy);
     histo_tot->Fill(xvar[i],yvar[i]);
     histo_tot_x->Fill(xvar[i]);
     histo_tot_y->Fill(yvar[i]);
     histo_B->Fill(xvar[i],yvar[i]);
     histo_B_x->Fill(xvar[i]);
     histo_B_y->Fill(yvar[i]);
     //std::cout << "i = " << i << " "<< xvar[i] << " "<< yvar[i] << std::endl; 
   };
   
   // Draw the histogram
   //histo->GetXaxis()->SetTitle("R [cm] "); // Let us assume a lenght on x axis
   //histo->GetYaxis()->SetTitle("Events per 0.08 cm "); 
   histo_tot->Draw("contZ");
   std::cout<< "Entries histo_tot " <<histo_tot->GetEntries() << std::endl;
   std::cout<< "Entries histo_A " <<histo_A->GetEntries() << std::endl;
   std::cout<< "Entries histo_B " <<histo_B->GetEntries() << std::endl;
   
   // ################################################
   // ###### FIT 2D ###################################
   // ################################################
   
   TFitter *fitter = new TFitter(PARAMETERS); //initialize TFitter with a maximum of 5 params
   fitter->SetDefaultFitter("Minuit"); // set minimizer. Default is Minuit.
   fitter->SetFCN(fcn); // set FCN

   // Set starting values and step sizes for parameters  
   //Double_t vstart[PARAMETERS] = {0.3,  -1.  , 1.  , 0.5 , 0.5 };
   //Double_t step[PARAMETERS]   = {0.0001, 0.0001, 0.0001, 0.0001, 0.0001};   //step 0 li rende costanti

   //Int_t SetParameter(Int_t ipar, const char* parname, Double_t value, Double_t verr, Double_t vlow, Double_t vhigh)
   fitter->SetParameter(0, "fA ", fA  , 0.0001, 0.,1.); // Bounded
   fitter->SetParameter(1, "mAx", mAx , 0.0001, 0.,0.);
   fitter->SetParameter(2, "mAy", mAy , 0.0001, 0.,0.);
   fitter->SetParameter(3, "mBx", mBx , 0.0001, 0.,0.);
   fitter->SetParameter(4, "mBy", mBy , 0.0001, 0.,0.);
   fitter->SetParameter(5, "sAx", sAx , 0.0001, 0.,0.);
   fitter->SetParameter(6, "sAy", sAy , 0.0001, 0.,0.);
   fitter->SetParameter(7, "sBx", sBx , 0.0001, 0.,0.);
   fitter->SetParameter(8, "sBy", sBy , 0.0001, 0.,0.);
   
   // Now ready for minimization step
   // Start minimization with arglist[0] max iterations and arglist[1] tolerance:
   // the default tolerance is 0.1, and the minimization will stop when
   // the estimated vertical distance to the minimum (EDM) is less than 
   // 0.001*[tolerance]*ERRDEF
   //Int_t ExecuteCommand(const char* command, Double_t* args, Int_t nargs)
   Double_t arglist[2] = {0.,0.1}; //
   fitter->ExecuteCommand("MIGRAD", arglist, 2);

   Double_t fcnmin, edm, errdef;
   Int_t nvpar, nparx;
   fitter->GetStats(fcnmin, edm, errdef, nvpar, nparx);
   
   Double_t vpar[PARAMETERS];
   for(Int_t k=0; k<PARAMETERS; ++k){
     vpar[k] = fitter->GetParameter(k);
     //std::cout << vpar[k] << std::endl;
   };


   // ################################################
   // ###### PROJECTIONS #############################
   // ################################################

 
   //TH2F *histo_proj_tot = new TH2F("histo_proj_tot","",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
   //TH2F *histo_proj_A   = new TH2F("histo_proj_A"  ,"",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
   //TH2F *histo_proj_B   = new TH2F("histo_proj_B"  ,"",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);

   //TH1F *histo_proj_tot_x = new TH1F("histo_proj_tot_x","",s_proj*bin_number_x,x_min,x_max);
   //TH1F *histo_proj_tot_y = new TH1F("histo_proj_tot_y","",s_proj*bin_number_y,y_min,y_max);
   //TH1F *histo_proj_A_x = new TH1F("histo_proj_A_x"    ,"",s_proj*bin_number_x,x_min,x_max);
   //TH1F *histo_proj_A_y = new TH1F("histo_proj_A_y"    ,"",s_proj*bin_number_y,y_min,y_max);
   //TH1F *histo_proj_B_x = new TH1F("histo_proj_B_x"    ,"",s_proj*bin_number_x,x_min,x_max);
   //TH1F *histo_proj_B_y = new TH1F("histo_proj_B_y"    ,"",s_proj*bin_number_y,y_min,y_max);


   Double_t x,y,weight,weight_A,weight_B;
    for(Int_t j=0;j<MAX_PROJ;j++){
      x = randGen.Uniform(x_max-x_min) + x_min;
      y = randGen.Uniform(y_max-y_min) + y_min;
      weight = f_fun_tot->Eval(x,y);
      weight_A = f_fun_A->Eval(x,y);
      weight_B = f_fun_B->Eval(x,y);

      histo_proj_tot   ->Fill(x,y,weight);
      histo_proj_A     ->Fill(x,y,weight_A);
      histo_proj_B     ->Fill(x,y,weight_B);
      histo_proj_tot_x ->Fill(x,weight);
      histo_proj_tot_y ->Fill(y,weight);
      histo_proj_A_x   ->Fill(x,weight_A);
      histo_proj_A_y   ->Fill(y,weight_A);
      histo_proj_B_x   ->Fill(x,weight_B);
      histo_proj_B_y   ->Fill(y,weight_B);
      
      //histo_A->Fill(xvar[i],yvar[i]);
      //std::cout << "i = " << i << " "<< xvar[i] << " "<< yvar[i] << std::endl; 
    };
    


    TCanvas *c_proj_tot_x = new TCanvas("c_proj_tot_x","Projection x",600,600);
    c_proj_tot_x->cd();
    histo_tot_x->GetXaxis()->SetTitle("x [cm] "); // Let us assume a lenght on x axis
    histo_tot_x->GetYaxis()->SetTitle("Events per 0.08 cm "); 
    histo_tot_x->Draw("e"); //data x
    histo_proj_tot_x->SetLineColor(2);
    histo_proj_tot_x->Scale(MAX/histo_proj_tot_x->Integral(1,bin_number_x));
    histo_proj_A_x->Scale((MAX*fitter->GetParameter(0))/histo_proj_A_x->Integral(1,bin_number_x));
    histo_proj_B_x->Scale((MAX*(1.-fitter->GetParameter(0)))/histo_proj_B_x->Integral(1,bin_number_x));
    //std::cout << "Integrale proj = " << histo_proj_tot_x->Integral(1,bin_number_x) << std::endl;
    //std::cout << "Integrale data = " << histo_tot_x->Integral(1,bin_number_x) << std::endl;
    histo_proj_A_x->SetLineColor(4);
    histo_proj_B_x->SetLineColor(4);
    histo_proj_A_x->Draw("C same");//projection A x
    histo_proj_B_x->Draw("C same");//projection B x
    histo_proj_tot_x->Draw("C same");//projection x

    TCanvas *c_proj_tot_y = new TCanvas("c_proj_tot_y","Projection y",600,600);
    c_proj_tot_y->cd();
    histo_tot_y->GetXaxis()->SetTitle("y [cm] "); // Let us assume a lenght on y axis
    histo_tot_y->GetYaxis()->SetTitle("Events per 0.08 cm "); 
    histo_tot_y->Draw("e"); //data y
    histo_proj_tot_y->SetLineColor(2);
    histo_proj_tot_y->Scale(MAX/histo_proj_tot_y->Integral(1,bin_number_y));
    histo_proj_A_y->Scale((MAX*fitter->GetParameter(0))/histo_proj_A_y->Integral(1,bin_number_y));
    histo_proj_B_y->Scale((MAX*(1.-fitter->GetParameter(0)))/histo_proj_B_y->Integral(1,bin_number_y));
    //std::cout << "Integrale proj = " << histo_proj_tot_y->Integral(1,bin_number_y) << std::endl;
    //std::cout << "Integrale data = " << histo_tot_y->Integral(1,bin_number_y) << std::endl;
    histo_proj_A_y->SetLineColor(4);
    histo_proj_B_y->SetLineColor(4);
    histo_proj_A_y->Draw("same");//projection A y
    histo_proj_B_y->Draw("same");//projection B y
    histo_proj_tot_y->Draw("same");//projection y


    // ################################################
    // ###### FIT 1D ###################################
    // ################################################

   TFitter *fitter1D = new TFitter(PARAMETERS); //initialize TFitter with a maximum of 5 params
   fitter1D->SetDefaultFitter("Minuit"); // set minimizer. Default is Minuit.
   fitter1D->SetFCN(fcn1D); // set FCN

   fitter1D->SetParameter(0, "fA ", fA  , 0.0001, 0.,1.); // Bounded
   fitter1D->SetParameter(1, "mAx", mAx , 0.0001, 0.,0.);
   fitter1D->SetParameter(2, "mBx", mBx , 0.0001, 0.,0.);
   fitter1D->SetParameter(3, "sAx", sAx , 0.0001, 0.,0.);
   fitter1D->SetParameter(4, "sBx", sBx , 0.0001, 0.,0.);
   
   //Int_t ExecuteCommand(const char* command, Double_t* args, Int_t nargs)
   //Double_t arglist[2] = {0.,0.1}; //
   fitter1D->ExecuteCommand("MIGRAD", arglist, 2);

   //Double_t fcnmin, edm, errdef;
   //Int_t nvpar, nparx;
   fitter1D->GetStats(fcnmin, edm, errdef, nvpar, nparx);
   
   
   
   // ################################################
   // ###### SEPARATION POWER ########################
   // ################################################
   
   // best separation power
   Double_t sigma_best;
   sigma_best = TMath::Sqrt(fA*(1-fA)/MAX);
   cout << " ####### SEPARATION POWER ########" << std::endl;
   cout << "sigma_best = " << sigma_best << std::endl;
   
   // calcolo 2D dal fit
   Double_t sigma_fit2D;
   sigma_fit2D = fitter->GetParError(0);
   cout << "sigma_fit2D = " << sigma_fit2D << std::endl;
   cout << "sigma_best/sigma_fit2D = " << sigma_best/sigma_fit2D << std::endl;
   
   // calcolo 1D dal fit
   Double_t sigma_fit1D;
   sigma_fit1D = fitter1D->GetParError(0);
   cout << "sigma_fit1D = " << sigma_fit1D << std::endl;
   cout << "sigma_best/sigma_fit1D = " << sigma_best/sigma_fit1D << std::endl;
   
    



#if 0
    //calcolo dal Minumu Variance Bound 2D
    Double_t sigma_mvb2D;
    histo_proj_A -> Scale(1./histo_proj_A->Integral(1,bin_number_x,1,bin_number_y));
    histo_proj_B -> Scale(1./histo_proj_B->Integral(1,bin_number_x,1,bin_number_y));
  
    TH2F *histo_num   = new TH2F("histo_num"  ,"",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
    TH2F *histo_den   = new TH2F("histo_den"  ,"",bin_number_x,x_min,x_max,bin_number_y,y_min,y_max);
    Double_t binX,binY;
    
    sigma_mvb2D = (1./MAX);
#endif    




}