Add files via upload

Author: xination

fit_dmeos/_01_basic_fit.C

@@ -0,0 +1,139 @@
+
+// this function will be used to set up our TF1 object 
+double myfunction( double* x, double* par ) {
+
+    // it takes in a pointer 'x'
+    // for example: double x[2] = { 0, 0);
+    // or double* x = new double [2]
+    // x[0] = x[1] = 0
+
+    
+    
+    double deg = x[0];
+
+    double c1  = par[0];
+    double m   = par[1];
+    
+    double ret = c1 + TMath::Sin( m * deg / 180 *  TMath::Pi() );
+    return ret;
+}
+
+
+
+// we will assign data for x and y here.
+// the x range is from xMin to xMax.
+// and we will have dataN points of (x,y)
+void generate_data( double* x, double* y, int dataN,	
+                    double xMin = 0., 
+                    double xMax = 180. ) 
+{
+    
+    // the answer.
+    // and we want the fitting to show c1 and m are close to 
+    // these values.
+    double c1 = 1.5;
+    double m  = 0.7;
+
+    TF1* ftemp = new TF1( "myfunc", myfunction, xMin, xMax, 2 ); 
+    
+    ftemp->SetParameters( c1 , m );
+    
+    for( int i = 0; i < dataN; i++ ) 
+    {
+    
+        x[i] = gRandom->Uniform( xMin, xMax );
+
+        y[i] = ftemp->Eval( x[i] ) + gRandom->Uniform(-0.01, 0.01 );	
+        
+        // we use TF1::Eval method to get the y value from 
+        // a given x, with our c1 and m parameters.
+        // we also add some noise signals.
+
+   }
+
+   delete ftemp;
+}
+
+
+
+
+
+void _01_basic_fit( ) 
+{
+
+
+    // STEP1:
+    // build our TF1 ( formula ) object
+    //
+    double xMin = 0;   
+    double xMax = 180;
+    int    parN = 2;   // the parameter numbers in the TF1.
+
+    TF1* f1 = new TF1( "myfunc", myfunction, xMin, xMax, parN ); 
+    /*
+        this is one of the constructor of TF1 class.
+        it takes in a function with  (Double_t*, Double_t*) arguments
+        and return a Double_t.
+         
+    */
+
+  
+    // set the names for the two parameters. 
+    f1->SetParNames( "c1", "m") ;
+
+    
+   
+
+
+    //===============================================================
+
+    // STEP2:
+    // assign some data.
+    const int dataN = 1000;
+    double x[dataN] = {0.0};
+    double y[dataN] = {0.0};
+
+    generate_data( x, y, dataN, xMin, xMax ); 
+    
+
+    TGraph* gr = new TGraph( dataN, x, y );
+    
+    // just for fun, let see what data look like.
+    TCanvas* c1 = new TCanvas("c1");
+    gr->Draw("AP*");
+
+
+
+
+
+
+    //===============================================================
+    // STEP3:
+    // do fitting and get results.
+
+    // set initial value, important for the fit.
+    f1->SetParameters( 0.0 , 1.0 );
+
+
+
+    // some options
+    //f1->SetParLimits(0, -1, 1 );  
+    // set 0th par to be bounded between -1 and 1.
+
+    // f1->FixParameter( 1, 0.8 );
+    // set the 1th par to be fixed at 0.8
+
+    gr->Fit( f1 , "Q" );
+    // Q = quiet
+    // N = not draw the fitted curve.
+    // R = using the range defined in TF1, not those from TGraph (or TH1)
+    // M = improve algorithm
+    // more options. goo.gl/odmhGU 
+
+
+
+    cout << "c1 = " << f1->GetParameter(0) << endl; 
+    cout << "m  = " << f1->GetParameter(1) << endl; 
+    cout << "Ndf =" << f1->GetNDF() << endl;
+    cout << "chisqr =" << f1->GetChisquare() << endl;
+}

fit_dmeos/_02_setup_TF1.C

@@ -0,0 +1,130 @@
+class gaus_class {
+
+public:
+    
+    double simple_gaus( double* t, double* par) { 
+        double x = t[0];
+        double h = par[0]; // hight
+        double c = par[1]; // center
+        double w = par[2]; // width
+        double temp = -0.5* ( (x-c)/w )*( (x-c)/w );
+	return h*exp(temp);
+    }
+};
+
+TGraph* gr;
+
+void _02_setup_TF1() {
+
+    //====================================================================
+    // to use the built-in function ( gaus, expo, polN )
+    // (you dont need to specify the parN.)
+    if( 1 ) {
+
+        TCanvas* c1 = new TCanvas("c1");
+        c1->Divide(1,3, 0, 0 );
+        
+        TF1* f1a = new TF1( "f1a", "gaus", -3, 3 ); // p0*exp(-0.5*((x-p1)/p2)^2)). 
+        TF1* f1b = new TF1( "f1b", "expo", -3, 3 ); // exp(p0+p1*x). 
+        TF1* f1c = new TF1( "f1c", "pol2", -3, 3 ); // p0 + p1*x +p2*x**2
+       
+        f1a->SetParameters( 1, 0, 0.5 );
+        f1b->SetParameters( 0, 1 );
+        f1c->SetParameters( 1, 1, 1);
+        
+        c1->cd(1);  f1a->Draw();
+        c1->cd(2);  f1b->Draw();
+        c1->cd(3);  f1c->Draw();
+    
+        
+ 
+
+
+    //====================================================================
+    // inline method:
+    // use [0] as 0th par, [1] as 1th par, etc ... 
+     
+
+        TCanvas* c2 = new TCanvas("c2");
+        c2->Divide( 2,1,0,0);
+
+        TF1* f2 = new TF1( "f2", "[0]*exp( -0.5* ( (x-[1])/[2] )**2 )", -3, 3 );
+        
+
+        f2->SetParameters( 1, 0, 0.5 );
+        f2->SetLineColor( kBlue );
+        c2->cd(1); f2->Draw();
+        c2->cd(2); f1a->Draw();
+    
+   
+    
+
+
+    //====================================================================
+    // using a method from a class.
+    // advantage: it can access the member varaibles in the class.
+     
+        
+        TCanvas* c3 = new TCanvas("c3");
+        c3->Divide( 3,1,0,0);
+        gaus_class* myGaus = new gaus_class();
+        TF1* f3 = 
+            new TF1( "f3", myGaus, &gaus_class::simple_gaus, -3, 3, 3 );
+        
+        f3->SetParameters( 0.5, 0., 0.5 );
+        f3->SetLineColor( kGreen );
+        c3->cd(1); f3->Draw();
+        c3->cd(2); f2->Draw();
+        c3->cd(3); f1a->Draw();
+    }
+      
+    
+
+
+    //====================================================================
+    // use TGraph as a function.
+    // we can use a lambda function to access TGraph object.
+   
+    if( 1 ) 
+    {
+
+        TCanvas* c4 = new TCanvas("c4", "c4");
+        
+        // let make some data for our TGraph object.
+        const int dataN = 100;
+        double xMin = 1;
+        double xMax = 10;
+        double x[dataN]; 
+        double y[dataN];  
+
+        for( int i =0; i<dataN; i++ )
+        {
+            x[i] =  xMin + (xMax-xMin)/ (dataN-1) * i ;
+            y[i]  = 1/x[i] + 1.0 ; 
+        }
+        
+        gr = new TGraph( dataN, x, y );
+     
+        auto lambda_func 
+            = [&] (double*x, double *par){ return par[0]*gr->Eval(x[0]); };
+
+        TF1 * f4 = new TF1( "f4", lambda_func, xMin, xMax, 1);
+    
+        // [] is the symbol for the start of lambda function.
+        // [&] means this lambda function can access the variables in current scope.
+        // so we can access gr in our lambda function.
+        // we have 1 parameters in the lambda function
+        // which is kind of scaling factor.
+
+        f4->SetParameter(0, 0.95 );
+
+        
+        
+        // draw the TF1 and TGraph together sometimes tricy 
+        // (and may casue memory issue).
+        f4->SetLineColor( kRed+1 );
+        f4->Draw( "" );
+        gr->Draw("same");
+    }
+     
+}

fit_dmeos/_03_fit_2D.C

@@ -0,0 +1,89 @@
+
+// gaus2d is for 2d gaussian function.
+Double_t gaus2d( Double_t* t, Double_t* par ) {
+
+    double x = t[0];
+    double y = t[1];
+
+    double a_x = par[0];
+    double c_x = par[1];
+    double s_x = par[2];
+
+    double a_y = par[3];
+    double c_y = par[4];
+    double s_y = par[5];
+
+
+    double termx = a_x * TMath::Exp( -0.5*(x-c_x)*(x-c_x) /s_x /s_x  );
+    double termy = a_y * TMath::Exp( -0.5*(y-c_y)*(y-c_y) /s_y /s_y  );
+    return termx * termy;
+
+}
+
+
+
+
+
+void _03_fit_2D() {
+
+    //======================================================
+    // Step 1
+    // prepare a TH2F histo for source data.
+    //
+    TH2F* histo2D = new TH2F( "histo2D", "histo2D",
+                               200, 0, 200,
+                               200, 0, 200 );
+    double width_x[3], width_y[3];
+    double center_x[3], center_y[3];
+
+    for( int i=0; i<10000; i++) {
+
+            histo2D->Fill(  gRandom->Gaus( 100, 5),
+                            gRandom->Gaus( 150, 3) );
+    }
+
+    // let's visualize the data
+    TCanvas* c1 = new TCanvas("c1","c1", 500, 375);
+    histo2D->Draw( "colz" );
+
+
+
+
+
+    //======================================================
+    // Step 2
+    // prepare a TF2 for the fitting.
+    
+
+    
+    TF2* f2 = new TF2( "f2", gaus2d, 50, 150, 50, 200, 6 );
+    // the syntax is very similar
+    // xMin, xMax, yMin, yMax, parN
+
+    // it is important to set inital values for fitting.
+    f2->SetParameters( 1000, 80, 8, 1000, 120, 3 ); 
+    f2->SetParLimits( 2, 0, 10); // for sigma_x
+    f2->SetParLimits( 5, 0, 10); // for sigma_y
+
+    f2->SetParNames( "height_x", "center_x", "sigma_x",
+                     "height_y", "center_y", "sigma_y" );
+
+
+
+    
+    // show the fit results.
+    histo2D->Fit( f2, "MN"  ); 
+    // "R" for using the range defined in TF2
+
+    cout <<  "==================\n" << endl;
+    
+    printf( "center is at  x=%6.3f, y=%6.3f\n",
+	    f2->GetParameter(1), f2->GetParameter(4));
+    
+    printf( "sigma_x = %6.3f, sigma_y = %6.3f\n",
+	    f2->GetParameter(2), f2->GetParameter(5)  );
+
+    histo2D->Draw();
+    f2->Draw( "same");
+
+}