... para pessoas que não sabem c++

Apresentação em tema: "... para pessoas que não sabem c++"— Transcrição da apresentação:

1 ... para pessoas que não sabem c++
Alexandre Suaide aula 2

2 O lego

3 Organização das aulas Aula 1 Comandos (realmente) básicos do ROOT Um pouco de c++ para usuários de ROOT Criando objetos simples (histogramas, gráficos, etc) Manuseando gráficos e histogramas. A interface gráfica Funções e ajustes de gráficos Aula 2 Macros Inovando sem perder a classe. Análise de dados no Pelletron ScanRoot e PelTools Debug, memory leaks e administrando objetos

4 Conjunto de comandos (como um programa) gravados em um arquivo.
Macros no ROOT O que é um macro? Conjunto de comandos (como um programa) gravados em um arquivo. Em geral é interpretado, mas pode-se compilar O processo de compilação exige que o macro esteja consistente com o c++ standard Como ler e executar .L – carrega um macro na memória .x – carrega e executa a função do macro cujo nome seja o mesmo do macro Ex: .x teste.C Carrega o macro teste.C e executa a função teste()

5 Exemplos simples Para executar Método 1 Método 2 Passando parâmetros
hello.C Para executar Método 1 Método 2 void hello() { cout <<"Hello world"<<endl; } root.exe [0] .L hello.C root.exe [1] hello() root.exe [0] .x hello.C Passando parâmetros Método 1 Método 2 root.exe [0] .L hist.C root.exe [1] hist(20,3) root.exe [0] .x hist.C(20,3) hist.C void hist(float mean, float RMS) { TH1F *h = new TH1F("h","teste",50,mean-4*RMS, mean+4*RMS); for(int i = 0;i<2000;i++) h->Fill(gRandom->Gaus(mean,RMS)); h->Draw(); }

6 Compilando macros... Tornando a execução mais rápida
Compilar macros torna a execução vezes mais rápida Para compilar um macro, digite, no prompt do linux compileMacro macro.C Esse comando só está disponível no PelTools O macro compilado gera uma biblioteca compartilhada (.so) Para carregar a biblioteca digite, no ROOT gSystem é uma variável de ambiente do ROOT (classe TSystem) root.exe [0] gSystem->Load(“macro.so”) Ex: macro hist.C compileMacro hist.C root root.exe [0] gSystem->Load(“hist.so”) root.exe [1] hist(20,3)

7 Alguns cuidados na hora de compilar macros
O processo de compilação utiliza um compilador padrão c++ Cuidado com a sintaxe. Em geral, o ROOT é muito tolerante com a sintaxe em c++. Macros interpretados rodam sem problemas mas na hora de compilar a estória é outra O compilador não sabe sobre as definições do ROOT Deve-se incluir explicitamente as definições de classes do ROOT (#include) O macro hist.C ficaria assim: #include “TRandom.h” #include “TH1.h” void hist(float mean, float RMS) { TH1F *h = new TH1F("h","teste",50,mean-4*RMS, mean+4*RMS); for(int i = 0;i<2000;i++) h->Fill(gRandom->Gaus(mean,RMS)); h->Draw(); }

8 Criando sem perder a classe
O ROOT oferece a possibilidade de criar as suas próprias classes Utilize o mesmo padrão de programação em c++ Porém o ROOT oferece algumas vantagens Integração completa com o framework do ROOT Criação de dicionários para utilizar o prompt de comando, incluindo a tecla TAB para completar comandos Gerenciamento de IO. Pode-se gravar objetos de classes criadas pelo usuário em arquivos root Atualização de versões. O ROOT gerencia automaticamente a evolução das classes que são criadas. Para usar essas benfeitorias deve-se seguir algumas regras

9 Regras para criação de classes (necessárias somente se você quiser integração total com o ROOT)
Classes devem ser derivadas do TObject ou TNamed (ou de outras classes derivadas delas) Isso inclui automaticamente métodos de IO, como Write(), Get(), etc... Utilizar os macros ClassDef e ClassImp na definição da classe Esses macros são essenciais na geração do dicionário e também no gerenciamento de versões O dicionário faz com que possa-se utilizar o prompt de comandos para manusear objetos definidos a partir de novas classes O gerenciamento de versões faz com que possa-se ler objetos de arquivos root criados a partir de definições antigas de novas classes. Ex: cria-se uma classe para cuidar de um telescópio E-DE. Faz-se algumas análises e grava-se alguns objetos em um arquivo. Após um tempo, muda-se a estrutura dessa classe para torná-la melhor. O gerenciamento de versões faz com que consiga-se ler os objetos definidos com a versão antiga da classe.

10 Exemplo TTeste.h TTeste.cxx Versão da classe #include "TObject.h"
class TTeste: public TObject { public: TTeste(); virtual ~TTeste(); ClassDef(TTeste,1) }; TTeste.cxx #include "TTeste.h" #include <iostream> using namespace std; ClassImp(TTeste) TTeste::TTeste() { cout <<"Esse é o construtor"<<endl; } TTeste::~TTeste() cout <<"Esse é o destrutor"<<endl; Versão da classe

11 Compilando classes Classes podem ser lidas do mesmo jeito que macros, porém compilar é muito mais eficiente Compilar classes no ROOT é algo que exige uns 3-4 comandos no prompt do Linux Compilar os arquivos propriamente ditos Gerar o dicionário com o comando rootcint Linkar o dicionário compilado com os outros arquivos compilados e gerar uma biblioteca compartilhada (.so) Assim, para facilitar a vida, existe o comando compile (somente no PelTools) Macro que compila todos os .cxx em um diretório, gera os dicionários, compila tudo e cria um arquivo .so

12 Algumas regras para o comando compile
Todos os arquivos devem estar em um único diretório Os headers devem ter extensão .h e os códigos, .cxx Cada classe deve ser definida em um arquivo .h cujo nome deve ser o mesmo da classe (facilita geração do dicionário) Ex: a classe TTeste deve ser definida no arquivo TTeste.h Uso: cd para o diretório onde estão as classes Digite compile [nome do arquivo .so]

13 Inclua no seu arquivo de login
ScanRoot e PelTools ScanRoot Versão modificada do ROOT que inclui bibliotecas e métodos para análise dos dados tomados no Pelletron Agrupa as funções do SCAN + DAMM Abre e lê arquivo de dados brutos (.FIL) Preenche histogramas a partir dos dados, etc PelTools Classe definida com algumas funções básicas para análise de dados no Pelletron, como traçar bananas, projeções, ajustes de picos etc. Setup Inclua no seu arquivo de login source /mnt/software/setup

14 Idéia por trás do ScanRoot
Os dados são adquiridos no Pelletron e gravados em um formato especial (.FIL) Bastante compacto Informação de cada evento separadamente Os dados devem ser processados para gerar os histogramas ou qualquer outra figura Aqui entra o ScanRoot ScanRoot em 4 etapas Abrir um arquivo de dados (.FIL) Abrir uma biblioteca com as funções que processarão os eventos Processar os eventos Gravar os resultados

15 ScanRoot Iniciando o programa. Digite: Para um help, digite: scanroot
******************************************* ** ** ** S c a n R o o t v ** ** (c) A. A. P. Suaide ** Running ScanRoot. type scanroot -help for options type menu() to open the ScanRoot Menu ScanRoot [0]> Iniciando o programa. Digite: Para um help, digite: scanroot scanroot -h ******************************************* ** ** ** S c a n R o o t v ** ** (c) A. A. P. Suaide ** usage: spmroot [-h|help] [-d|debug] [-t|tools] [file1] [file2] ... -h or -help displays this message -d or -debug turns on debug mode and display event by event information -n or -nogui does not open the ScanRoot Menu file1, file2,... open root files and display the browser

16 A interface gráfica Como processar um arquivo .FIL
Clique em Open .FIL e selecione o arquivo Clique em Load Histograms e selecione a biblioteca com as definições dos histogramas Clique em GO Clique em Save Histograms para salvar os histogramas gerados Para abrir a janela de análise, clique em PelTools Menu

17 Além da interface gráfica, há comandos para o prompt
Comandos básicos hac(“filename”) Carrega arquivo de definição de histogramas openInput(“filename”) Abre o .FIL openOutput(“filename”,outNumber) Abre um novo arquivo FIL para gravação loadL2(“filename”) Carrega definição de trigger de software saveHist(“filename”) Grava arquivo de histogramas go(N) Processa N eventos (N=0 processa o arquivo inteiro) tools() Abre a janela de PelTools help()

18 Analisando dados Usando o prompt de comando (RootCint)
Alta flexibilidade Interpretador c++/ROOT Usando o PelTools Pequena interface gráfica que auxilia, dentre outras coisas Criação de bananas (TCutG) Projeção de histogramas Ajustes de picos, etc Ajuste bastante rudimentar (precisa desenvolvimento)

19 Como fazer histogramas
Pequena rotina em c++ Todo o poder do c++ e do ROOT disponíveis Não precisa compilar O ScanRoot compila sozinho Mesmo programa pode ser usado para aquisição de dados (SPMRoot) Header Incluir bibliotecas básicas Definir variáveis globais 4 funções (2 obrigatórias) bookHistograms() fillHistograms() init() finish()

20 Mantendo a memória em ordem
Objetos criados no heap (comando new) só são deletados quando explicitamente requisitados Isso gera um problema de gerenciamento de memória Considere o seguinte exemplo void hist() { TH1F *h = new TH1F("h","teste",50,0,10); } root.exe [0] for(int i=0;i<10;i++) hist(); Vários objetos são criados com o mesmo nome, além disso, os ponteiros são perdidos. Perdeu-se o acesso àquele objeto mas a memória continua alocada MEMORY LEAK

21 Algumas ferramentas no auxílio de gerenciamento
O ROOT possui alguma classes para ajudar no gerenciamento do sistema como um todo TROOT Ponto de entrada do ROOT. Permite acesso a cada objeto criado dentro do ROOT, além de outras informações do sistema (variável global gROOT) TSystem Define a interface básica com o sistema operacional (variável global gSystem) TMemStat Auxilia na monitoração do uso de memória TBenchmark Auxilia na medida de tempo (total e CPU) de processamento de um certo processo

22 Procurando objetos na memória (gROOT)
O ROOT mantém uma lista de objetos criados na memória. Essa lista é indexada pelo nome do objeto. TROOT::FindObject(char* name); Retorna o ponteiro para o objeto cujo nome é “name” Resolve somente casos onde o endereço (ponteiro) do objeto foi perdido. Objetos criados com o mesmo nome são perdidos, a menos que se tome o cuidado de guardar os ponteiros dos mesmos root.exe [0] TH1F *h = gROOT->FindObject(“h”); TROOT::ls(); Lista o conteúdo da memória do ROOT root.exe [0] gROOT->ls(); TROOT* Rint The ROOT of EVERYTHING OBJ: TH1F h teste : 0 at: 0x8d4ca20

23 TMemStat fornece informação sobre o uso de memória no ROOT
TMemStat::PrintMem(“”); Fornece a quantidade de memória sendo usada e quanto essa memória cresceu/diminuiu desde a última solicitação root.exe [60] TMemStat m root.exe [61] m.PrintMem("") TMemStat:: total = heap = ( ) root.exe [62] for (int i=0;i<10000;i++) hist() Warning in <TH1::Build>: Replacing existing histogram: h (Potential memory leak). ... root.exe [64] m.PrintMem("") TMemStat:: total = heap = ( ) Essa mensagem aparece porque tenta-se criar vários objetos com o mesmo nome.

24 TBenchmark é um relógio para medir o desempenho de execução do código
Vários métodos Start(“”) – Inicia relógio Stop(“”) – Para relógio GetRealTime(“”) – Fornece tempo real de execução GetCpuTime(“”) – Fornece tempo de cpu root.exe [67] TBenchmark b root.exe [68] b.Start(""); for(int i=0;i<1000;i++) hist(); b.Stop(""); Warning in <TH1::Build>: Replacing existing histogram: h (Potential memory leak). ... root.exe [69] b.GetRealTime("") (Float_t) e+00 root.exe [70] b.GetCpuTime("") (Float_t) e-01

25 Como resolver o nosso problema de memory leak
Duas situações diferentes Eu só quero 1 histograma por vez na memória Tenho que destruir o velho antes de criar o novo Nesse caso, costuma-se dizer que o objeto pertence à função pois a função decide se o objeto continua vivendo ou não Eu realmente necessito de vários histogramas na memória Ou eu ponho nomes diferentes para cada histograma... ...ou eu mantenho os ponteiros de cada histograma construído com o mesmo nome Nesse caso, costuma-se dizer que o objeto não pertence à função pois ela não controla a vida do mesmo

26 Caso 1: Eu só quero 1 histograma por vez
Usar o ROOT para verificar se o objeto já existe na memória e deletá-lo, caso necessário void hist() { TH1F *h = gROOT->FindObject("h"); if (h) delete h; h = new TH1F("h","teste",50,0,10); } Esse procedimento é lento pois, a cada chamada da função, a mesma precisa procurar pelo objeto. Porém, é seguro. root.exe [1] TMemStat m; root.exe [2] m.PrintMem("") TMemStat:: total = heap = ( ) root.exe [3] for(int i =0;i<10000;i++) hist() root.exe [4] m.PrintMem("") TMemStat:: total = heap = ( ) Não foi alocada memória adicional

27 Caso 2: o usuário controla o número de histogramas
Vamos fazer direito Cada objeto possui um nome distinto A função retorna um ponteiro do objeto criado TH1F* hist(int index) { TString nome = "hist"; nome+=index; // cria um histograma cujo nome é histxxxx TH1F *h = new TH1F(nome,nome,50,0,10); return h; // retorna o ponteiro do objeto recem criado } Houve aumento da memória utilizada... ...mas o usuário tem controle sobre ela root.exe [1] TH1F *hist[10000] root.exe [2] TMemStat m; root.exe [3] m.PrintMem("") TMemStat:: total = heap = ( ) root.exe [4] for(int i =0;i<10000;i++) hist[i] = hist(i) root.exe [5] m.PrintMem("") TMemStat:: total = heap = ( ) root.exe [6] for(int i =0;i<10000;i++) delete hist[i] root.exe [7] m.PrintMem("") TMemStat:: total = heap = ( )

28 Quando gerenciamento de memória é importante
Do ponto de vista do programador Sempre Do ponto de vista do cientista Quando não fazer gerenciamento causar problema Na prática, deve-se tomar cuidado com a memória. Quando um trabalho for feito de tal forma que cria-se algumas centenas ou milhares de objetos, dependendo do tamanho de cada um, pode-se, facilmente, alocar praticamente toda a memória disponível, o que pode acarretar no término do programa por falta de memória ou na completa degradação da performance devido ao fato do computador começar a fazer swap em disco. Programinhas onde somente são criados alguns objetos, apesar de não ser elegante, pode-se viver com um pequeno vazamento de memória.

29 Como conseguir mais informação
Site do ROOT Documentação das classes Alguns documentos interessantes (root, c++) Incluindo essas aulas Download ROOT (+scanroot e PelTools)

30 ... Para finalizar