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 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 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ção O ROOT possui centenas de classes diferentes Clique na classe que mais satisfaz as suas necessidades

Os objetos podem ser criados de várias formas Obtendo informação 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 Construtores Os 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

Obtendo informação 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 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?

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? 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çõ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); f->SetParameter(2,9); g->Fit(f);

Adicionando 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 Exemplo TLegend *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) Vamos criar um histograma fajuto  TF1 *f = new TF1(“f”,”[0]*exp([1]*x)+gaus(2)+gaus(5)”,0,10); f->SetParameter(0,40); f->SetParameter(1,-0.3); f->SetParameter(2,20); f->SetParameter(3,4.3); f->SetParameter(4,0.2); f->SetParameter(5,56); f->SetParameter(6,8); f->SetParameter(7,0.2); 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 – Gaussiana polN – 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 histograma h->Fit(f); Como extrair informações da função ajustada que não seja pela tela?

Outro exemplo de fit (com histogramas) [0]*exp([1]*x)+gaus(2)+gaus(5) 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); 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õ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áficos gROOT (TROOT) → controle geral do ROOT gSystem (TSystem) → interface com sistema operacional gPad (TPad) → sempre aponta para o pad que esta acionado

Fazendo 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 .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 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) 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) 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á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).

TBrowser Interface gráfica para navegar os arquivos e objetos na memória do computador new TBrowser();

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

TCanvas (editor e toolbar)

Pró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 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 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 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