Alexandre Suaide aula 2. Resumo da semana anterior Root é uma coleção de classes para análise de dados com um interpretador c++ C++ –Pequena introdução

Alexandre Suaideaula 2

Resumo da semana anteriorResumo da semana anterior

• Root é uma coleção de classes para análise de dados com um interpretador c++

• C++– Pequena introdução dos conceitos mais

básicos– Comandos mais comuns– Classes e objetos

• ROOT– Como criar e preencher histogramas– Gráficos e funções

Entendendo como as coisas funcionamEntendendo como as coisas funcionam

• Para conhecer as classes do ROOT e as suas funcionalidades, é necessário pensar em uma estrutura de árvore– Uma classe pode ser

derivada de muitas outras

– Uma funcionalidade específica pode estar escondida em uma outra classe

• Manual de classes do ROOT– http://root.cern.ch/

root/Categories.html

Obtendo informaçãoObtendo informação

• O ROOT possui centenas de classes diferentes– Clique na

classe que mais satisfaz as suas necessidades


Nome da classe

Árvore de derivação: todos os métodos públicos

dessas classes são acessíveis por um objeto

TH2F.Ex: SetLineColor() muda a

cor da linha no histograma e é um método da classe

TAttLine

ConstrutoresOs objetos podem ser

criados de várias formas

Métodos públicos

Se o que você procura não está

aqui, tente procurar em uma das

classes mães


Nome da função

documentação: todos os métodos públicos

das classes do ROOT possuem documentação

detalhada, descrevendo os parâmetros e, em muitos casos, com exemplos e

figuras ilustrativas

Todas as funções possuem links

Se você tem dúvida pode seguir os links e obter mais informação

Nesse ponto, acabou a novidadeNesse ponto, acabou a novidade

• Toda a teoria de como usar o ROOT se resume a– Saber programar em c++– Conhecer as classes do ROOT

• O mais importante para isso é estar sintonizado e familiarizado com os tutoriais e documentação no site do ROOT

– Isso não quer dizer que não tem mais nada a aprender...• O c++ e ROOT são bastante ricos e em alguns casos as

soluções não são tão obvias

• O aprendizado se faz na prática...– Entrada de dados em um gráfico– Manipulando gráficos e histogramas de 1 e 2

dimensões– ScanRoot

Problema: como criar um gráfico a partir de dados em um arquivo de texto?

Problema: como criar um gráfico a partir de dados em um arquivo de texto?

Exemplo: criando um gráfico com barras de incerteza

Exemplo: criando um gráfico com barras de incerteza

O arquivo dados.dat contém 3 colunas, x, y, ey. No prompt do ROOT, digite

Root [1]: TGraphErrors *g = new TGraphErrors(“dados.dat”,"%lg %lg %lg");Root [2]: g->Draw(“AP”);

Simple, isnt´t it?

Como trabalhar diretamente com os atributos de um gráfico?

Como trabalhar diretamente com os atributos de um gráfico?

TCanvas *c1 = new TCanvas(“canvas”,”janela de grafico”,600,600);

c1->SetLogy();

TGraphErrors *g = new TGraphErrors(“teste.dat”,"%lg %lg %lg");

g->Draw(“AP”);

g->SetTitle(“Electrons from heavy quarks decay”);

g->SetMarkerStyle(20);

g->SetMarkerColor(2);

g->SetLineColor(2);

TAxis* Y = g->GetYaxis();

Y->SetTitle(“1/(2#pi p_{T}) d^{2}N/dp_{T}d#eta”);

Y->SetTitleSize(0.03);

Y->SetLabelSize(0.03);

Y->SetTitleOffset(1.4);

TAxis* X = g->GetXaxis();

X->SetTitle(“p_{T} (GeV/c)”);

X->SetTitleSize(0.03);

X->SetLabelSize(0.03);

Letras gregas e outros caracteres especiais de LaTEX podem ser obtidos com a mesma

sintaxe do LaTEX, substituindo \ por #

Fazendo ajustes de funçõesFazendo ajustes de funções

• Vamos utilizar o nosso bom e velho gráfico do slide anterior• Método mais simples de ajuste: utilizar TF1

TF1 *f = new TF1(“f”,”[0]*pow(1+x/[1],-[2])”,0,15);

f->SetParameter(0,1);

f->SetParameter(1,1.5);


g->Fit(f);

BABApow ),(

Adicionando legenda aos gráficosAdicionando legenda aos gráficos

• Utilize a classe TLegend– TLegend *l = new TLegend(xmin,ymin,xmax,ymax);

• Os valores são fração do tamanho da janela gráfica e não coordenadas reais nos graficos

– l->AddEntry(objeto,”label”,”modo de exibição”);• Modos de exibição

– l = linha– p = ponto– f = cor de preenchimento

• ExemploTLegend *l = new TLegend(0.67,0.75,0.87,0.87);

l->AddEntry(g,”dados”,”p”);

l->AddEntry(f,”ajuste”,”l”);

l->Draw();

Outro exemplo de fit (com histogramas)Outro exemplo de fit (com histogramas)

• Vamos criar um histograma fajuto TF1 *f = new TF1(“f”,”[0]*exp([1]*x)+gaus(2)+gaus(5)”,0,10);


f->SetParameter(1,-0.3);







TH1F* h = new TH1F(“hist”,”teste”,100,0,10);

for(int i=0; i<8000; i++) h->Fill(f->GetRandom());

h->Draw();

Funções pré-definidas. O Root possui algumas funções pré-definidas,

tais como:

gaus – GaussianapolN – polinômio de grau N (N = 0...9)landau – distribuição de Landau

expo – exp([0]+[1]*x)

Outro exemplo de fit (com histogramas) [0]*exp([1]*x)+gaus(2)+gaus(5)


• Vamos ajustar o histogramah->Fit(f);

• Como extrair informações da função ajustada que não seja pela tela?



• Qual o Х2red do ajuste?

f->GetChisquare()/f->GetNDF();

1.36299

• Qual o número de contagens no primeiro pico?TF1 *peak = new TF1(“peak”,”gaus(0)”,0,10);

peak->SetParameters(f->GetParameters()+2);

peak->Draw(“same”);

peak->Integral(0,10);

53.5103

peak->Integral(0,10)/h->GetBinWidth(23);

535.103

• E no segundo?peak->SetParameters(f->GetParameters()+5);

peak->Integral(0,10)/h->GetBinWidth(23);

1349.11

Essa é uma operação com ponteiros. Se você checar a documentação do ROOT verá que o

método GetParameters() retorna um Double_t* que indica a posição na memória onde os parâmetros estão guardados. O +2 indica o deslocamento dentro dessa

memória

Caso operações com ponteiros incomodem, pode-se fazer na força bruta:

peak->SetParameter(0,f->GetParameter(2));peak->SetParameter(1,f->GetParameter(3));peak->SetParameter(2,f->GetParameter(4));

Integral, por definição, inclui o tamanho do canal. Caso o canal não

tenha tamanho == 1, deve-se ter

cuidados extras

Histogramas de duas dimensõesHistogramas de duas dimensões

TGraph* dedx = new TGraph("dedx.dat","%lg %lg");dedx->Draw("AL"); Tcanvas* c1 = new TCanvas();f->Draw(); // essa é a mesma função usada anteriormente

TRandom *r = new TRandom();TH2F* h2 = new TH2F("h2", "#DeltaE_{gas} x E_{total} para

^{7}Li", 100,0,10,100,0,2);for(int i=0;i<8000;i++){ float e = f->GetRandom(); float de = r->Gaus(dedx->Eval(e),0.1); h2->Fill(e,de);} Tcanvas* c2 = new TCanvas();gStyle->SetPalette(1,0);h2->Draw("colz");

O ROOT possui objetos pré-definidos para auxiliar a configuração geral do ambiente. Dentre eles estão:

gStyle (TStyle) → configurações padrões de estilos gráficosgROOT (TROOT) → controle geral do ROOT

gSystem (TSystem) → interface com sistema operacionalgPad (TPad) → sempre aponta para o pad que esta acionado

Fazendo projeções de um histogramaFazendo projeções de um histograma

• Projetar o histograma no eixo-y (similar para o eixo-x)– ProjectionY(“nome”,bin1,bin2,”opções”);– Note que os parâmetros são os números dos

bins e não os valores no eixo • Exemplo TAxis* X = h2->GetXaxis();

int bin1=X->FindBin(7.5);

Int bin2=X->FindBin(9)

TH1D* projTotal = h2->ProjectionY(“total”);

TH1D* projBins = h2->ProjectionY(“bins”,bin1,bin2);

projTotal->Draw();

projBins->Draw(“same”);

Gravando objetos em arquivos .rootGravando objetos em arquivos .root

• Ok, criei meus gráficos, histogramas, funções ou qualquer outro objeto do ROOT. Como eu posso armazená-los?

• O Root possui um sistema de arquivos complexos, onde TODOS os seus objetos podem ser salvos em um arquivo com estrutura de diretórios.

• TFile– Classe do ROOT para abrir, ler, gravar e

manipular arquivos .root

TFile: Gravando objetos em um arquivoTFile: Gravando objetos em um arquivo

• Uso– TFile f(“nome_do_arquivo”,”opções”);– TFile* f = new TFile(“nome_do_arquivo”,”opções”);

• Opções– NEW ou CREATE – Abre o arquivo para escrita. Se o

arquivo já existir, nada acontece– RECREATE – Abre a arquivo para escrita. Se o arquivo

já existir, escreve por cima.– READ (ou sem opção) – Abre o arquivo para leitura.

• Gravando e lendo objetos– Para gravar, use a função Write() dos objetos a

serem gravados– Para ler, use a função Get(“nome”) do objeto TFile

Gravando objetos no arquivo (Write)Gravando objetos no arquivo (Write)

• Criamos vários objetos em vários exemplos. Como podemos gravá-los em um arquivo?

TFile file("teste.root","RECREATE"); file.cd(); // muda o diretorio padrão para o arquivo criado g->Write(); dedx->Write(); f->Write(); h->Write(); h2->Write(); projTotal->Write(); projBins->Write(); file.ls(); // lista o conteudo do arquivo file.Close(); // fecha o arquivo

Lendo objetos do arquivo (Get)Lendo objetos do arquivo (Get)

• Como eu recupero o histograma “h2” do arquivo?– O importante são os nomes dos objetos, que se obtém a

partir do método ls() da classe TFile. TFile file("teste.root"); // abrir para leitura file.cd(); TH2F* myhist = (TH2F*)file.Get(“h2”); myhist->Draw(“colz”);

• Importante!!!– Não feche o arquivo enquanto estiver trabalhando com o

histograma, pois o mesmo será removido da memória

ROOT e a interface gráficaROOT e a interface gráfica

• O uso do ROOT em linha de comando é bastante útil– Permite automatizar as tarefas– Possibilidades praticamente ilimitadas– Análises complexas

• Porém, muitos atributos podem ser alterados graficamente– Torna a manipulação mais fácil e intuitiva

no mundo “for windows” atual• O ROOT possui uma interface gráfica com

recursos complexos (e em expansão).

TBrowserTBrowser

Interface gráfica para navegar os arquivos e objetos na memória do computador

new TBrowser();

TCanvasTCanvas

Janela gráfica para uso geral (use botão da direita para menus)

new TCanvas();

TCanvas (editor e toolbar)TCanvas (editor e toolbar)

Próxima semanaPróxima semana

• Os conceitos básicos para uma análise de dados no nosso ambiente foram exploradas com o ROOT.– É possível ir adiante?

• É claro, as possibilidades são muita grandes

• Semana que vem– ScanRoot

• Adaptando o ROOT às necessidades das análises no Pelletron

• Como usar e tirar proveito do ROOT nesse ambiente• Lendo arquivos .FIL, .spk e trabalhando como os

nossos dados– Bananas, projeções, contas com parâmetros, etc.

Extras... Para quem estiver interessadoExtras... Para quem estiver interessado

• Entrada e saída de dados em um arquivo texto

• Na primeira aula nós vimos como entrar e sair dados do teclado e monitor– cout << “Ola, quantos anos voce tem? “;– cin >> idade;

• O c++ permite a mesma estrutura para entrada e saída de dados de um arquivo através das classes– ifstream

• Para entrada de dados

– ofstream• Para saída de dados

Entrada de dados a partir de um arquivo ASCIIEntrada de dados a partir de um arquivo ASCII

• Vamos utilizar o mesmo arquivo do começo dessa apresentação– dados.dat – três colunas de dados

float x[100],y[100],e[100]; // vetores para armazenar os dados

ifstream entrada(“dados.dat”); // cria o objeto entrada para ler os dados

int n = 0; // numero de linhas lidas

while(!entrada.eof()) // a função eof() indica se chegou no fim do arquivo

{

entrada >> x[n] >> y[n] >> e[n]; // mesma sintaxe do cin

n++

}

entrada.close(); // fecha o arquivo

Saída de dados para um arquivo ASCIISaída de dados para um arquivo ASCII

• Vamos escrever os dados lidos na transparência anterior para um arquivo novosDados.dat– três colunas de dados x, y, e

// of vetores de dados (x,y,e) bem como o numero de dados (n)

// supõe-se já definidos na transparência anterior

ofstream saida(“novosDados.dat”); // cria o objeto saída para os dados

for(int i=0; i<n; i++) // loop sobre todos os dados

{

saida <<x[i]<<“ “<<y[i]<<“ “<<e[i]<<endl; // mesma sintaxe do cout

}

saida.close(); // fecha o arquivo

Documents

Alexandre Suaide aula 2. Resumo da semana anterior Root é uma coleção de classes para análise de dados com um interpretador c++ C++ –Pequena introdução