Installed version 6.30 with homebrew (11-12-2023)
  $ brew install root
  
  

-------------Browser

-------------Tipi di dati

rendono il codice platform independent

-------------Classi di Root (iniziano pet T)

------------CINT (interprete C++)

--------Nple e istogrammi da files

TFile signal("data/signal.root");

----------Istogrammi 1d

Float_t sum = 0;
for (Int_t i=1; i<=10; i++) {
  sum += h1->GetBinContent(i);
}

----------Istogrammi 2d

-------------Istogrammi Profile

dichiarazione:
TProfile nome("nome","titolo",Xbin,Xmin,Xmax,Ymin,Ymax);

disegna (mostra il valor medio di Y e il suo RMS per ciascun bin di X):
nome->Draw();

disegna senza mostrare le barre d'errore:
nome->Draw("hist");

----------------Graph

Int_t n = 5;
Float_t x[n], y[n];
for(Int_t i=0; i<5; i++) 
{x[i]=i;
 cout << x[i] << endl;
}
y[0]=0.0;
y[1]=1.0;
y[2]=3.0;
y[3]=6.0;
y[4]=10.0;

grafico senza barre d'errore:		 
TGraph *geff = new TGraph(n,x,y);
geff->Draw("AL*");     // disegna una spezzata e una * ad ogni punto
geff->Draw("AP");     // disegna gli assi e il marker corrente

grafico con errori simmetrici	 
TGraphErrors *gerr = new TGraphErrors(n,x,y,xerr,yerr);

----------------Macro un-named

includere i comandi in un file tra parentesi {}
ecco un esempio di file macro.cc:

{
TFile signal("data/signal.root");
signal.ls();
selectedtree.SetLineColor(kRed);
selectedtree->Draw("mes");
}

esecuzione macro:
.x macro.cc

----------------Macro named

includere i comandi in una funzione che abbia
lo stesso nome del file:

#include < iostream >
void macro(int j = 1) {
cout << "Hello" << endl;
int i = j;
cout << "i = " << i << endl;
}

esecuzione macro:
.x macro.cc(10)

o in alternativa
(in tal caso la funzione puo' avere anche nome diverso dal file):

.L macro.cc
macro(10)

per compilare lo script:

.L macro.cc+
macro(10)

per forzare la compilazione:

.L macro.cc++
macro(10)

----------------Scrivi su file root nuovo

Si puo' dare il comando TFile all'inizio, oppure, come nell'esempio che segue, 
alla fine dopo aver creato gli istogrammi o Nple da salvare nel file:

TH1F *istog = new TH1F("istog","titolo",10,-10.,10.);
istog->Fill(2,10.7);
istog->Fill(4,6.7);
TFile *file = new TFile("nuovofile.root","RECREATE","comment");
file->cd();
istog->Write();
file->Close();
		  
--------------------Input output con file (istruzioni C++)

ofstream myfile;           // crea un file come stream e inserisce una linea
myfile.open ("filename.txt");
myfile << "Writing this to a file.\n";
myfile.close ();	  

ifstream myfile;           // apre il file come stream e legge ciascuna linea
myfile.open("filename.txt");
   Double_t x[100] = {0.};
   Int_t j;
   j=0;
   while ( true ) {
     myfile >> x[j];
     if( myfile.eof() ) break;
     ++j;
   };   
myfile.close();
   
-------------------Nple ovvero Trees

I trees possono avere branches (sottodirectory) e 
leaves (sono le variabili che contengono dati, ordinate in colonne)

lista delle variabili:
selectedtree->Print();

stampa il contenuto delle variabili:
selectedtree->Scan();

plot di una variabile:
selectedtree->Draw("de");

scatter plot:
selectedtree->Draw("px:py");

scatter plot con taglio:
selectedtree->Draw("px:py","abs(de)<0.01");

definizione variabile di taglio:
TCut cut1 = "abs(de)<0.01";
selectedtree->Draw("px:py",cut1);

opzioni di Draw nel terzo campo:
selectedtree->Draw("px:py","","same");
selectedtree->Draw("px:py","","l");

proiezione di Nple su istogramma 1d:
selectedtree->Draw("de>>istogramma");
istogramma.Draw();

aggiungi all'istogramma gia' esistente:
selectedtree->Draw("de>>+istogramma");

-------------------Reading from ASCII file

es. filename.txt
#cost  time   type
1.46   127    2
1.56   126    11
0.82   71     3

TNtuple calls("calls","calls","cost:time:type");
calls.ReadFile("filename.txt");

-------------------Reading from Root file

TFile f("rootfile.root");
TNtuple * calls = f.Get("calls");

-------------------Istogramma da un folder aliroot/subfolder

TFile *f1 = new TFile("filename");
TFolder *f2 = (TFolder *)f1->Get("aliroot");
TH1D *h1 = (TH1D*)f2->FindObject("subfolder/histo");
h1->Draw();

TFile *f1 = new TFile("filename");
TFolder *f2 = f1->FindObjectAny("aliroot");
TFolder *f3 = f2->FindObjectAny("subfolder");
TH1D *h1 = (TH1D*)f3->FindObject("histo");
h1->Draw();

-------------------Merge di Nple contenute in file diversi

TChain catena("Nple");
catena.Add("outputfile1.root");
catena.Add("outputfile2.root");
catena.Merge("newfile.root");

in alternativa, comando da shell:
hadd newfile.root outputfile1.root outputfile2.root
hadd newfile.root outputfile*

-----------------Reading data from a Tree

si faccia uso della seguente macro:

{
TFile signal("data/signal.root");
TTree * albero = (TTree*)signal.Get("selectedtree");
Float_t de;
albero->SetBranchAddress("de", &de);
for(int iEvt = 0; iEvt < albero->GetEntries(); iEvt++)
{
  albero->GetEntry(iEvt);
  cout << "candidate iEvt = " << iEvt << "\t de = " << de << endl;
}
}

-------------------Building a tree from scratch

{
Float_t x,y;
TTree slope("slope","pendenza");
TBranch * b_x = slope.Branch("x", &x, "variabile x");
TBranch * b_y = slope.Branch("y", &y, "variabile y");
for(Int_t i = 0; i < 100; i++)
{
  x = i/2.;
  y = x*x;
  slope.Fill();
}
}

--------Grafica

clear della finestra:
c1->Clean();

dividi la finestra in diverse TPad:
c1->Divide(2,2);

cambia la TPad attiva:
c1->cd(1);
 
salva in un file:
c1.Write();

salva in diversi formati:
c1->SaveAs("file.ps");
c1->SaveAs("file.eps");
c1->SaveAs("file.gif");
c1->Print("file.eps");
c1->Print("file.pdf");
				 
disegna linea dal punto x1,y1 al punto x2,y2:
l = new TLine(x1, y1, x2, y2);
l->Draw();

colore linea:
l->SetLineColor(2);

disegna cerchio centrato in x,y di raggio r:
c = new TEllipse(x, y, r, r);
c->Draw();

disegna arco di ellisse centrata in x,y assi a1,a2
compresa tra gli angoli phimin,phimax:
e = new TEllipse(x, y, a1, a2, phimin, phimax);
e->Draw();

colore riempimento:
e->SetFillColor(2);

---------------------Funzioni

crea una funzione:
TF1 *f1 = new TF1("f1", "x*sin(x)", 0, 10);

plot della funzione:
f1->Draw();

cancella la funzione:
f1->Delete();

uso del valore della funzione in un punto:
Double_t a, b;
b = f1->Eval(a);
	      
crea una named macro:
crea un file hello.cc contenente le istruzioni es.
  void hello(int t)
  {
    for (int i=1; i<=t; i++) cout << "Hello World" << endl;
  }

quindi carica le funzioni col comando:
.L hello.cc
a questo punto si possono chiamare le funzioni:
hello(5);

crea una funzione con parametri:
Double_t straight_line(Double_t *x, Double_t *par)
{
  Double_t m,q; // Linear slope
  q = par[0];
  m = par[1];
  return q + m*x[0];
}
TF1 *f_line = new TF1("f_line",straight_line,0,10,2);
						      
---------------------Generazione di numeri casuali

#include 
						      
generazione distribuzione uniforme [0,1]:
TRandom3 randGen;
Double_t x = randGen.Rndm();
						      
generazione distribuzione uniforme [3,10]:
TRandom3 randGen(0);						      
Double_t uni = randGen.Uniform(3,10);					
						      
generazione distribuzione gauss (media = 0, sigma = 1):
TRandom3 r3(0);
Double_t y = r3.Gaus(0,1);

generazione distribuzione esponenziale (tau = 5):
TRandom3 rexp(0);
Double_t evar = rexp.Exp(5);