(r10) EPUniandes2011TC3 < Main

Main Web>TWikiUsers>AndresOsorio>EscuelaParticulasUniandes>EPUniandes2011>EPUniandes2011TC3 (revision 10) (raw view)~~EditAttachPDF~~
<style type="text/css" media="all">
  pre {
    text-align: left; 
    padding: 10px;
    margin-left: 20px; 
    color: black;
  }
pre.command {background-color: white; border-color: black;}
pre.cfg {background-color: lightblue;}
pre.code {background-color: 	#EEE8AA;}
pre.output {background-color: lightgreen;}
</style>

---+!! Taller 3

%TOC%

---+++ Convenciones utilizadas en esta guía

   * <pre class = "command">%RED%Comandos escritos en la Linea de Comando de Linux (CLI) van en rojo y en marcados</pre> %ENDCOLOR%
   * %BLUE%Texto en azul es para ser reemplazado por algún un valor indicado%ENDCOLOR%
   * %PINK%Argumentos opcionales o pasos opcionales van en rosado.%ENDCOLOR%
   * <pre class = "code">Lineas de codigo de algun archivo mas en este fondo beige</pre>
   * Usaré como editor *gedit*. Si ustedes son familiares con algun otro, pueden usarlo.

---+++ Material

El material para este taller, se puede descargar del siguiente link:

   * [[%ATTACHURL%/ejercicios-Parte3.tgz][ejercicios-Parte3.tgz]]: Ejercicios Parte TC3

O si prefiere, lo puede descargar directamente desde la terminal usando el comando *wget*:

<pre class = "command">
%RED%wget --no-check-certificate http://hep.uniandes.edu.co/~aosorio/Particulas/TC2011/ejercicios-Parte3.tgz
tar xzvf ejercicios-Parte3.tgz
cd ejercicios-Parte3%ENDCOLOR%
</pre>

En esta carpeta, se encuentra el codigo necesario para la hacer los ejercicios. Tambien existe una carpeta *solucion* que contiene el codigo completo.

---+++ Ejercicio 1 – Creación de un simple Histograma

El primer ejercicio consistirá en la creación de un Histograma con informacion de la cinematica de algunas particulas. Editemos el script que se trabajo al final del Taller 2 y que simula eventos de Supersimetria:

<pre class = "command">
%RED%gedit pythia8_susy.C%ENDCOLOR%
</pre>

   * Quitar el comentario en la linea siguiente del codigo y escribir el numero de bins 50 y el rango del histograma XMIN=0 y XMAX=100:

<pre class = "code">
%BLUE%//%ENDCOLOR%TH1F * h1 = new TH1F("hpt", "Muons Pt", %BLUE%50, 0, 100%ENDCOLOR%);
</pre>

   * Esta linea define un Histograma 1D ( clase [[http://root.cern.ch/root/html/TH1F.html][TH1F]] ).

   * Bajar hasta donde está el ciclo de generación y buscar la linea con el comentario "// Particle Loop" y agregrar el siguiente codigo:

<pre class = "code">
while( iev < maxEvts ) {
    
    pythia8->GenerateEvent();
    if (iev < 1) pythia8->EventListing();
    pythia8->ImportParticles(particles,"All");
    
    Int_t np = particles->GetEntriesFast();

    // Particle loop
    
    %BLUE%for (Int_t ip = 0; ip < np; ip++) {
      
      //Leemos informacion de cada particula

      TParticle* part = (TParticle*) particles->At(ip); //Esta es la particula i
      Int_t ist = part->GetStatusCode(); //obtenemos su estatus
      Int_t pdg = part->GetPdgCode(); // y su codigo PDG
      
       //1. Introducir una codicion para separar los muones

      //Queremos graficar el momento Transverso de los muones Pt == Sqrt(px*px + py*py)
      //2. Obtener aqui las componentes Px y Py del momento de las particulas

      //3. Llenar el histograma h1 con el momento transversar

      
    } // No olvidar! cerrar el loop que hemos introducido %ENDCOLOR%

</pre>

Estudiemos que esta pasando aqui: 

   * El primer ciclo, es un ciclo sobre la generacion de eventos . Por ello es que la condicion es hacer este ciclo hasta que alcance el maximo numero de eventos que hemos especificado desde el principio del script. La generacion esta instruida por el comando *pythia8->GenerateEvent();*

   * El segundo ciclo, aquel que hemos introducido, hace *por cada evento* un ciclo sobre el numero maximo de particulas que Pythia ha generado. El maximo numero de particulas se obtiene con el metodo *Int_t np = particles->GetEntriesFast();*

   * Los muones tienen por código de identificación 13 y -13 (para el anti-mu). Volvemos a este comentario mas adelante

   * Cada partícula está representada por un objeto de tipo [[http://root.cern.ch/root/html/TParticle.html][TParticle]] y queremos graficar el momento transversal de cirtas particulas
      * Mirando en la documentación TParticle, como podríamos obtenerlo?

   * Por el momento, el codigo introducido no hace aun lo que queremos. Recordemos, queremos hacer 3 cosas:

   1. Entre la particulas, identificar aquellas que son muones -es decir con codigo 13 y -13
   1. Un vez identificadas, tenemos calcular el momento transversal
   1. Llenar el histograma que creamos para hacer 

   * Por lo tanto, debemos copiar el siguiente codigo - guiarse por los comentarios:

<pre class = "code">

      //1. Introducir una codicion para separar los muones
      %BLUE%if ( pdg == 13 || pdg == -13 ) {%ENDCOLOR%

      //Queremos graficar el momento Transverso de los muones Pt == Sqrt(px*px + py*py)
      //2. Obtener aqui las componentes Px y Py del momento de las particulas

      %BLUE%float px = part->Px();
      float py = part->Px();
      float Pt = sqrt(px*px + py*py);%ENDCOLOR%

      //3. Llenar el histograma h1 con el momento transversar
      %BLUE%h1->Fill( Pt );%ENDCOLOR%
 
      %BLUE%} ///no olvidar! cerrar el condicional %ENDCOLOR%

</pre>
  
    * Bien! Esto nos sirve para llenar el histograma. Ahora, si queremos visualizar el histograma debemos introducir al final de todo los ciclos lo siguiente:

<pre class = "code">
    // Ahora podemos dibujar el histograma y que lo muestre en pantalla
    %BLUE%h1->Draw();%ENDCOLOR%
</pre>

   * Guarde las modificaciones y cierre. Ejecutar ahora el script desde la terminal:

<pre class = "command">
%RED%root -l pythia8_susy.C%ENDCOLOR%
</pre>

La opción -l ("menos L minuscula") evita que salga la imagen de saludo de ROOT, lo que nos ahorra algunos milisegundos.


%TWISTY{mode="div" showlink="Show results..." hidelink="Hide results..." remember="on" 
                showimgleft="%ICONURLPATH{toggleopen-small}%" 
                hideimgleft="%ICONURLPATH{toggleclose-small}%"}%

<img src="%ATTACHURLPATH%/muonpt-1.jpg" alt="muonpt-1.jpg" width="696" height="472" />

%ENDTWISTY%

---+++ Ejercicio 2 – !PythiaAnalsis – Una clase para hacer el análisis sobre datos simulados

Ahora lo que queremos es introducir una técnica para el análisis de datos simulados.

Hemos trabajadoe en el script *pythia8_susy.C*, el cual genera los eventos y los guarda en un archivo de formato de ROOT (manejado por la clase [[http://root.cern.ch/root/html/TFile.html][TFile]]). En el script, la creacion del archivo ocurre en la siguiente linea:

<pre class = "code">
//Definir archivo de salida
TFile * outfile = new TFile("eventos_pythia8_SUSY.root","RECREATE");
</pre>
 
Dentro de este archivo existe lo que se conoce como un [[http://root.cern.ch/root/html/TTree.html][TTree]] – un árbol – en el que cada rama corresponde a las variables que poseen las partículas y las hojas son los valores que toman por evento. Este árbol se define en la siguiente linea del código:

<pre class = "code">
TTree*tree= new TTree("tree","Arbol con particulas segun Pythia8");
tree->Branch("particles",&particles);
</pre>

¿Cómo hacer un analisis de los datos contenidos en este árbol? Lo haremos utilizando una clase llamada *PythiaAnalysis*. Esta clase es automáticamente generada por ROOT basada en la *estructura que tiene árbol* (%PINK%ver nota Suplementaria No 1%ENDCOLOR%). La clase *PythiaAnalysis* se declara y define en dos archivos:

   * *PythiaAnalysis.h*: declaración de la clase, sus variables y metodos
   * *PythiaAnalysis.C*: definición del metodo *Loop*. Este metodo realiza un ciclo/loop sobre los eventos contenidos en el árbol

Miremos el archivo *PythiaAnalysis.h*

<pre class = "command">
%RED%gedit PythiaAnalysis.h%ENDCOLOR%
</pre>

   * El este archivo se declara la clase *PythiaAnalysis*. Contiene toda una serie de arreglos, los cuales definen el contenido por evento de cada particula simulada.
   * Tambien contiene unos metodos (en el contexto de C/C++). Entre los mas importantes, se encuentran un *constructor* y otros metodos que se encargan de asociar y llenar cada uno de de los arreglos con los datos contenidos en el arbol. 
   * Para nosotros, el metodo que vamos a modificar es el llamado *Loop*, el cual hace un ciclo sobre los eventos generados. Este metodo se define en el archivo *PythiaAnalisis.C*. Editemos entonces este archivo:

<pre class = "command">
%RED%gedit PythiaAnalysis.C%ENDCOLOR%
</pre>

Intentemos hacer de nuevo un histograma que nos cuente el numero de muones por evento. Nos concentraremos en implementar el método *Loop( )* que se encarga de hacer la iteración sobre los eventos almacenados.

   * Para ello debemos adicionar un segundo ciclo, que nos itere sobre la particula i-esima, parecido a lo que hicimos en el ejercicio anterior:
   * En este ciclo, preguntamos por el PDG_ID de la particula y comparamos
   * Adicionamos una condición y un contador para muones
   * Finalizado este loop podemos entonces graficar la distribución del número de muones por evento

Nota: la lectura del TTree nos hace perder los objetos partículas como tales (TParticle). Su información se encuentra ahora en forma de arreglos o *arrays* a la C/C++ (ver !PythiaAnalysis.h).

   * Uno tiene dos opciones: 

   1. leer y manipular los arreglos 
   1. leer los arreglos y crear de ellos objetos TParticle

Para este ejercicio, haremos una sencilla modificacion del metodo *Loop()* y utilizaremos los arreglos.


<pre class = "code">

   //Adicionar un histograma para contar el numero de muones
  %BLUE%TH1F * h1 = new TH1F("nmu","Muones por eventos", 50, 0, 15); %ENDCOLOR%

  // Empieza loop sobre eventos  
  for (Long64_t jentry=0; jentry<nentries;jentry++) { 

    Long64_t ientry = LoadTree(jentry);
    if (ientry < 0) break;
    nb = fChain->GetEntry(jentry);   nbytes += nb;
    
    //Implementar aqui el analisis
    
    %BLUE%int maxpart = particles_; //maxpart contiene el numero maximo de particulas
    int n_muons = 0; //contador para el numero de muones _por_ evento
    
    for (int i = 0; i < maxpart; ++i ) // ciclo sobre particulas por evento
    {
      
      if( abs( particles_fPdgCode[i] ) == 13 ) //condicion que nos identifica los muones ( de codigo +13/-13)
        ++n_muons; //incrementamos el contador
      
    }
    
    h1->Fill(n_muons); //llenamos el histograma%ENDCOLOR% 


  }//cierra loop sobre eventos  
   
  //Graficar el histograma del numero de muones por evento
  %BLUE%h1->Draw();%ENDCOLOR% 

</pre>

Como correr este codigo? Un forma sencilla es la de cargar esta clase al inicio de la sesion en ROOT:

<pre class = "command">
%RED%root -l%ENDCOLOR%
root [0] %RED%gROOT->LoadMacro("PythiaAnalysis.C")%ENDCOLOR%
(Int_t)0
</pre>

Si todo sale bien, no deberia haber ningun mensaje de error. Si aparece alguno, hay que leer el mensaje. Posiblemente ha quedado algo mal escrito durante la modificacion realizada al metodo *Loop()*.

Ahora para correr este codigo, necesitamos dos lineas. La primera sera crear un apuntador a un objeto de la clase *PythiaAnalysis* y luego a este apuntador, hacer que corra el metodo *Loop()*. El constructor de un objeto *PythiaAnalysis* toma como argumento el nombre del archivo (va entre comillas) en donde se encuentran los datos simulados.

<pre class = "command">
root [1] %RED%PythiaAnalysis * susy = new PythiaAnalysis("eventos_pythia8_SUSY.root");%ENDCOLOR%
root [2] %RED%susy->Loop()%ENDCOLOR%
</pre>

   * En este ejemplo, *susy* es un apuntador a un objeto de tipo *PythiaAnalysis*. Una vez creado el objeto al que apunta, podemos llamar el metodo *Loop* y hacer el analisis sobre los eventos simulador.


%TWISTY{mode="div" showlink="Show results..." hidelink="Hide results..." remember="on" 
                showimgleft="%ICONURLPATH{toggleopen-small}%" 
                hideimgleft="%ICONURLPATH{toggleclose-small}%"}%

<img src="%ATTACHURLPATH%/nmuones-2.png" alt="nmuones-2.png" width="648" height="485" />

%ENDTWISTY%

Para hacer esto de una forma mas automatica, %PINK%ver nota Suplementaria No 2%ENDCOLOR%.

---+++ Ejercicio 3 – !JetPythiaAnalysis – Una clase para hacer el análisis sobre datos simulados incluyendo Jets

Ahora queremos introducir una técnica para el análisis de datos simulados usando los algoritmos de reconstrucción ded Jets que nos da el paquete [[http://fastjet.fr/][FastJet]] (incluido en el Live-CD que ustedes tienen). Esto lo hemos implementado en una clase llamada *JetPythiaAnalysis* la cual posee las mismas caracteristicas de *PythiaAnalysis*, pero además incluye la posibilidad de reconstruir Jets.

   * Abrir los archivos !JetPythiaAnalysis.h y !JetPythiaAnalysis.C : explorar
      * Al igual que en el caso anterior, en !JetPythiaAnalysis.h se declara la clase (con sus variables y metodos)
      * !JetPythiaAnalysis.C contiene la definicion del metodo *Loop()* 
   * Vamos a editar el archivo *JetPythiaAnalysis.C*

La idea es la de construir Jets a partir de partículas estables o cuyo tiempo de vida es suficiente para que alcancen a llegar a los distintos instrumentos de deteccion que se colocan en un detector de particulas. Por ejemplo, dentro de este tipo de particulas tendriamos muones, electrones, piones, kaones. En este ejercicio haremos la reconstruccion de Jets segun un algorithmo en especial, el [[http://arxiv.org/abs/hep-ph/0210022][Kt-jet]] y graficaremos la distribucion de momento transversal. Para ello los pasos a seguir son:

   1. Definir el algoritmo para la reconstruccion de Jets
   1. Definir el histograma
   1. Hacer un ciclo sobre particulas por evento y seleccionar aquellas que sean *estables* y que *detectables*. Por *detectables* nos referimos a que particulas que podrian ser vistas en el detector y no particulas que como neutrinos escaparian a la deteccion.
   1. Llenar un contenedor con estas particulas
   1. Correr el algorithmo de reconstruccion de Jets
   1. Hacer un ciclo sobre los Jets resultantes, extraer su momento transversal y pasar el valor al histograma
   1. Una vez terminado el ciclo sobre eventos, graficar

Editar el archivo !JetPythiaAnalysis.C siguiendo los comentarios que alli se encuentran:

<pre class = "command">
%RED%gedit JetPythiaAnalysis.C%ENDCOLOR%
</pre>

e introducir las siguientes lineas de codigo:

   * Definir el algoritmo para reconstruir jets

<pre class = "code">
  //Definir el tipo de Algoritmo para reconstruir Jets y pasarle el parametro requerido
   %BLUE%double R = 0.7;
   fastjet::JetDefinition jet_def(fastjet::kt_algorithm, R);%ENDCOLOR%
</pre>

   *  Definir el histograma que vamos a llenar

<pre class = "code">
  //Definir un histograma para el momento transversal de los Jets
 %BLUE%TH1F * h_JetPt = new TH1F("JetsPt","Momento transversal de Jets ",50, 0, 100);%ENDCOLOR%
</pre>

   * En el ciclo de eventos, insertar un ciclo sobre particulas y colocar alli las condiciones necesarias para seleccionar las particulas estables y detectables y llenar un contenedor.

<pre class = "code">
    int np = 0;
     int max_part = particles_; //Maximo numero de particulas

    // Definit un contenedor de Particulas para pasarle a FastJet
     %BLUE%std::vector<fastjet::PseudoJet> particles;%ENDCOLOR%
    
    //Implementar aqui el analisis
     while ( np < max_part )  {
      
      //llenar aqui con las particulas estables: estas particulas serian aquellas que no tienen hijas

      %BLUE%if ( (particles_fDaughter[np][0] == -1) && (particles_fDaughter[np][1] == -1) ) 
      {

        bool isDetectable = true;

        // tenemos que saltarnos aquellas particulas que aun siendo estables, no serian detectables directables
	// 12 = nu_e ; 14 = nu_mu ; 16 = nu_tau ; 10000022 = SUSY LSP / neutrinalino

        if ( abs (particles_fPdgCode[np]) == 12 || 
	     abs (particles_fPdgCode[np]) == 14 || 
	     abs (particles_fPdgCode[np]) == 16 || 
	     abs (particles_fPdgCode[np]) == 10000022 )
			isDetectable = false;

        // lenamos el contenedor con particulas estables
        if( isDetectable ) particles.push_back( fastjet::PseudoJet( particles_fPx[np], 
                          	                                    particles_fPy[np],
                          	                                    particles_fPz[np],
                          	                                    particles_fE[np] ) );
      
       } %ENDCOLOR%//Este cierra la condicion
      
      ++np; // pasamos a la siguiente particula
       
    }
</pre>

   * Ejecutar el algoritmo de reconstruccion de Jets y hacer un ciclo sobre el resultado. Extraer el momento transversal de cada Jet y llenar el histograma con este valor.

<pre class = "code">
    %BLUE%if ( particles.size() <= 0 )
      continue;%ENDCOLOR%
    
    // Corremos ahora FastJet: hacer sobre las particulas la identificacion de Jets
     %BLUE%fastjet::ClusterSequence Cluster(particles, jet_def);%ENDCOLOR%

    // Objeto Cluster contiene los jets: podemos guardarlos en un contenedor de Jets
     %BLUE%std::vector<fastjet::PseudoJet> jets = Cluster.inclusive_jets();%ENDCOLOR%
    
    // Ahora podemos hacer un ciclo sobre los jets reconstruidos y extraer el momento transversal
    // - llenar histograma

     %BLUE%for (unsigned i = 0; i < jets.size(); i++) {

      h_JetPt->Fill( jets[i].perp() );
      
    }%ENDCOLOR%

     %BLUE%jets.clear(); %ENDCOLOR%//Limpiar el contenedor de jets y particulas en preparacion para el proximo evento
     %BLUE%particles.clear(); %ENDCOLOR%

</pre>

   * Por fuera del ciclo sobre los eventos, graficar el histograma:

<pre class = "code">
  // Dibujar la distribucion de momento transversal
   %BLUE%h_JetPt->Draw();%ENDCOLOR%
</pre>

   * Listo, esas serian todas las modificaciones a hacer al codigo. Para correr vamos a necesitar algunas cosas mas. Editar el archivo siguiente y seguir comentario:

<pre class = "command">
%RED%gedit rootlogon.C%ENDCOLOR%
</pre>

<pre class = "code">
   //Para el ejercicio 3: needCompilation = true
   bool needCompilation =  %BLUE%true;%ENDCOLOR%
</pre>

   * Que ocurre? Resulta que para poder usar *FastJet* dentro de ROOT, necesitamos una opcion que cargue la libreria de !FastJet y que *compile* el codigo que hemos realizado, a diferencia de los pasos anteriores. Esto lo podemos instruir para que se haga automaticamente al inicio de ROOT desde este archivo *rootlogon.C* (ver nota Suplementaria N2).

   * Si todo ha quedado bien escrito, ROOT compila exitosamente las dos clases !PythiaAnalysis y !JetPythiaAnalysis.

<pre class = "command">
%RED%root -l%ENDCOLOR%
Info in <TUnixSystem::ACLiC>: creating shared library /ejercicios-Parte3/solucion/./PythiaAnalysis_C.so
Info in <TUnixSystem::ACLiC>: creating shared library /ejercicios-Parte3/solucion/./JetPythiaAnalysis_C.so
root [0]
</pre>

   * Para correr !JetPythiaAnalysis, tenemos que hacer dos pasos muy similares a los del ejercicio N2:

<pre class = "command">
%RED%root -l%ENDCOLOR%
Info in <TUnixSystem::ACLiC>: creating shared library /ejercicios-Parte3/solucion/./PythiaAnalysis_C.so
Info in <TUnixSystem::ACLiC>: creating shared library /ejercicios-Parte3/solucion/./JetPythiaAnalysis_C.so
root [0] %RED%JetPythiaAnalysis * jets = new JetPythiaAnalysis("eventos_pythia8_SUSY.root");%ENDCOLOR%
root [1] %RED%jets->Loop(); %ENDCOLOR%
#--------------------------------------------------------------------------
#                      FastJet release 2.4.2
#            Written by M. Cacciari, G.P. Salam and G. Soyez            
#                         http://www.fastjet.fr                         
#								      	   
# Longitudinally invariant Kt, anti-Kt, and inclusive Cambridge/Aachen  
# clustering using fast geometric algorithms, with area measures and optional
# external jet-finder plugins.                                          
# Please cite Phys. Lett. B641 (2006) [hep-ph/0512210] if you use this code.
#								      	   
# This package uses T.Chan's closest pair algorithm, Proc.13th ACM-SIAM 
# Symp. Discr. Alg, p.472 (2002), S.Fortune's Voronoi algorithm and code .
#-------------------------------------------------------------------------
</pre>

   * El mensaje en pantalla es un mensaje de bienvenida de !FastJet. El resultado de nuestro analisis sera algo como esto:


%TWISTY{mode="div" showlink="Show results..." hidelink="Hide results..." remember="on" 
                showimgleft="%ICONURLPATH{toggleopen-small}%" 
                hideimgleft="%ICONURLPATH{toggleclose-small}%"}%

     <img src="%ATTACHURLPATH%/jets-Pt-3.png" alt="jets-Pt-3.png" width="696" height="472" />

%ENDTWISTY%

Eso sería todo! Buena suerte.

---+++ Nota Suplementaria N1

Estos son los pasos para crear una clase para hacer el analisis de un TTree:

<pre class = "command">
%RED%root -l%ENDCOLOR%
root [0] %RED%TFile *_file0 = TFile::Open("eventos_pythia8_SUSY.root");%ENDCOLOR%
root [1] %RED%_file0->cd();%ENDCOLOR%
root [2] %RED%TTree *t1 = (TTree*)gDirectory->FindObjectAny("tree");%ENDCOLOR%
root [3] %RED%t1->MakeClass("MyFirstROOTclass");%ENDCOLOR%
Info in <TTreePlayer::MakeClass>: Files: MyFirstROOTclass.h and MyFirstROOTclass.C generated from TTree: tree
</pre>

---+++ Nota Suplementaria N2

Cada vez que uno inicia ROOT, el programa busca en la carpeta en donde se encuentra parado un script llamado *rootlogon.C*. Si no existe, ROOT inicia con los valores que trae por por defecto. Si existe, entonces ejecuta este script, dando la oportunidad de que el usuario introduzca cambios en las configuracion inicial. Nosotros podemos usar este script para que carge automaticamente las clases que necesitamos. Este seria un ejemplo del contenido de dicho script:

<pre class = "code">
// Contenido del archivo rootlogon.C
void rootlogon() 
{
gROOT->LoadMacro("PythiaAnalysis.C");
}
</pre>

De esta forma nos evitamos este paso. Para ejecutar, el *Loop* sobre unos datos podemos guardar las dos lineas en un *macro*. Un *macro* almacena los comandos que dariamos a ROOT en una sesion interactiva, los cuales deben ir entre dos corchetes *{* y *}*. Al igual que en C/C++ cada comando debe ir separado por un *;*. Por ejemplo, uno podria almacenar todo en el siguiente macro:

<pre class = "code">
// Contenido del archivo runAnalysis.C
{

PythiaAnalysis * susy = new PythiaAnalysis("eventos_pythia8_SUSY.root");
susy->Loop();

}
</pre>

Este *macro* se puede ejecutar de dos formas:

   * Desde linea de comando:

<pre class = "command">
%RED%root -l runAnalysis.C%ENDCOLOR%
</pre>

   * Desde ROOT con el comando *.x* (punto x):

<pre class = "command">
%RED%root -l %ENDCOLOR%
root [0] %RED%.x runAnalysis.C%ENDCOLOR%
</pre>

-- Main.AndresOsorio - 15-May-2012
Attachments
Topic attachments
I	Attachment	History	Action	Size	Date	Who	Comment
jpg	muonpt-1.jpg	r1	manage	39.3 K	2012-05-22 - 17:10	AndresOsorio	muonpt-1
png	jets-Pt-3.png	r1	manage	9.0 K	2012-05-24 - 17:32	AndresOsorio	Jetspt-3
png	nmuones-2.png	r1	manage	8.5 K	2012-05-22 - 18:46	AndresOsorio	nmuones-2
tgz	ejercicios-Parte3.tgz	r1	manage	49.9 K	2012-05-24 - 18:19	AndresOsorio	material P3
Topic revision: r10 - 2012-05-31 - AndresOsorio
Main
Webs
Public webs
Welcome Guest
- Cern Search
- TWiki Search
- Google Search
Main All webs