// Utilizzo della classe TF1 e TCanvas

#include "TCanvas.h"
#include "TF1.h"
#include "TApplication.h"
#include <iostream>
#include <cmath>

using namespace std;

#define EPS 1.e-10

double lorentzianPeak(double x[], double par[]){

  double Den = (x[0]-par[2])*(x[0]-par[2]) + par[1]*par[1]/4.;
  if ( Den < EPS ) Den = EPS;
  return ( par[0]*par[1]/(2.*M_PI) )/ Den;

}

int main (int argc, char**argv)
{
  
  TApplication app("App",0,0);

  // =========================================================================================
  // Definizione di una funzione f1
  // =========================================================================================
  
  TF1 *f1 = new TF1("f1","sin(x)/x",0.,10.);
  cout << "Plotting function -------" << endl;
  
  // Creo un oggetto della classe TCanvas: e' la finestra grafica
  // sulla quale metto il disegno
  
  TCanvas *c1 = new TCanvas("c1","funzione",600,400);  
  
  // Disegna la funzione sul canvas
  
  f1->Draw();                           
  
  cout << "Il valore di f1 in 1 vale       -->> " << f1->Eval(1.) << endl;          // Valutarla in un punto  
  cout << "La derivata di f1 in 1 vale     -->> " << f1->Derivative(1.) << endl;    // Valutarne la derivata in un punto  
  cout << "L'integrale di f1 in [0,1] vale -->> " << f1->Integral(0.,1.) << endl;   // Calcolare l'integrale definito

  // =========================================================================================
  // Definizione una funzione con parametri
  // =========================================================================================
  
  TF1 *f3 = new TF1("f3","[0]*x*sin([1]*x)",-3.,3.);
  TCanvas *c3 = new TCanvas("c3","funzione",600,400);
  f3->SetParameter(0,10.);     // Definire il parametro [0] a 10.
  f3->SetParameters(10.,5.);   // Definire [0] -> 10. e [1] a 5.
  f3->Draw();
  
  // =========================================================================================
  // Oppure...
  // =========================================================================================
  
  TF1 *lp = new TF1("lp",lorentzianPeak,-3.,3.,3);  // L'ultimo intero definisce il numero di parametri
  TCanvas *c4 = new TCanvas("c4","Lorentzian Peak",600,400);
  lp->SetParameters(1.,1.,0.);
  lp->Draw();

  app.Run();

  return 0;

}

 

#include "TCanvas.h"
#include "TApplication.h"
#include "TH1F.h"
#include "TF1.h"
  
#include <iostream>
#include <fstream>
 
using namespace std;
 
int main (int argc, char**argv)
{
   
  TApplication app("App",0,0);

// Definizione di un istogramma monodimensionale da riempire con float

  TH1F *h1 = new TH1F("h1","Istogramma 1D",100,-5.,5.);
  h1.StatOverflows( kTRUE ); // utilizza underflow e overflow per calcoli statistici
  
// assumo di avere dei numeri immagazzinati in un file gaus.dat

  fstream f ;
  f.open("gaus.dat",ios::in);
  double x ;
  while ( f >> x ) {
    h1->Fill(x);  // riempimento
  }
  f.close();
  
  // creazione del canvas

  TCanvas *c1 = new TCanvas("c1","Istogramma 1D",600,400);
  
  // disegno.

  h1->Draw();
  h1->GetXaxis()->SetTitle("Titolo sull'asse X");
  h1->GetYaxis()->SetTitle("Titolo sull'asse Y");
  h1->Draw();
  
  // Puoi prendere le informazioni che ti interessano
  
  cout << "La media dell'istrogramma h1 vale -->>  " << h1->GetMean() << endl;
  cout << "L'RMS dell'istogramma h1 vale     -->>  " << h1->GetRMS() << endl;
  
  // Puoi fittare l'istogramma con una funzione gaussiana (e' gia' predefinita in ROOT)

  h1->Fit("gaus");
  
  // e recuperare i risultati
  
  TF1 *FitFun = h1->GetFunction("gaus");
  cout << "Ecco i parametri del fit " << endl;
  cout << "Media della gaussiana --->>> " << FitFun->GetParameter(1) << endl;
  cout << "Sigma della gaussiana --->>> " << FitFun->GetParameter(2) << endl;
  cout << "Chi2 del fit          --->>> " << FitFun->GetChisquare() << endl;
  
  c1->Print("HistoFit.pdf");
  
  app.Run();
  return 0;
  
}

 

#include "TCanvas.h"
#include "TApplication.h"
#include "TGraph.h"
#include "TF1.h"

#include <cmath>
#include <iostream>
#include <fstream>

using namespace std;

int main (int argc, char**argv)
{
  
  TApplication app("App",0,0);

  // construisco il grafico

  TGraph * g = new TGraph() ;
  
  // riempio il vettore con dei punti costruiti artificialmente

  for (int i = 0; i < 20; i++){   
    double x = 0.5 * i;
    double y = 10.*sin( x+0.2 );		      
    g->SetPoint(i, x , y);
  }
    
  // Disegnare il grafico (N.B.: viene creato automaticamente un TCanvas di nome c1)
  
  TCanvas *mygraph = new TCanvas("mygraph","Grafico") ;
  g->Draw("AL*");   // A = Disegna gli assi
                    // L = Congiunge i punti con una linea spezzata
                    // * = Segna i punti con un *
  

  TF1 *f1 = new TF1("f1","[0]*sin([1]*x+[2])",0.,10.);

  f1->SetParameter(0,10.);     // Definire il parametro [0] a 10.
  f1->SetParameters(5.,1.,0.1);   // Definire [0] -> 10. e [1] a 5.

  g->Fit(f1);
  cout << "Parametro 0 del fit : " << f1->GetParameter(0) << endl;
  cout << "Parametro 1 del fit : " << f1->GetParameter(1) << endl;
  cout << "Parametro 2 del fit : " << f1->GetParameter(2) << endl;

  // Cambiare il tipo di punto
  
  TCanvas *mygraph1 = new TCanvas("mygraph1","Grafico") ;
  g->SetMarkerStyle(21);
  g->SetMarkerColor(9);
  g->Draw("ALP");   // P = Segna i punti con il punto corrente
  
  // Sovrapporre un altro grafico

  TGraph *h = new TGraph("punti.dat");
  h->SetMarkerStyle(20);
  h->SetMarkerColor(3);
  h->Draw("CP");    // C = Congiunge i punti con una linea continua  

  app.Run();

  return 0;

}