Está en la página 1de 37

Universidad Nacional de Ingeniería.

GEANT4
Ticse Torres Royer
Dávila Aguilar Houston

Tópicos Especiales IV: Física de Partículas

Diciembre-2009
INTRODUCCIÓN
La Física Nuclear y la Investigación de altas energías tal como la conocemos hoy en día no sería
posible sin las simulaciones. La producción masiva de muestras de eventos similares a los
previstos en los experimentos reales es una parte integral del proceso de diseño, construcción, y la
comisión de la muy complejo de aceleradores y detectores de partículas utilizados en
experimentación y la física nuclear.

Las simulaciones son también esenciales para desarrollar las herramientas de software, el estrés,
la infraestructura informática de prueba, y analizar los datos recogidos por los experimentos.

GEANT4
GEANT4 es un conjunto de herramientas para la simulación de partículas elementales y los
núcleos que al pasar por un material, interaccionan con los núcleos de dicho material. En él se
describe el seguimiento de las partículas a través de una geometría compuesta de diferentes los
materiales, sus interacciones con los electrones y los núcleos que se encuentran y la creación de
otras partículas en estas interacciones. GEANT4 es completamente una re-ingeniería de objetos,
sucesor orientada a Geant3, y un proyecto pionero para adaptarse con éxito las técnicas modernas
de ingeniería de software a la simulación del detector de partículas y física nuclear. Es un conjunto
de herramientas, está diseñada para el modelo de todos los elementos asociados con la
simulación del detector: la geometría del sistema, los materiales involucrados, las partículas de
fundamental interés, la generación de eventos primarios, el seguimiento de las partículas de
a través de materiales y campos electromagnéticos, los procesos que rigen la física de partículas
interacciones, la respuesta de los componentes del detector, sensibilidad, la generación de datos
de eventos, almacenamiento de eventos y pistas, la visualización del detector y trayectorias de las
partículas, y la captura y análisis de datos de simulación en los diferentes niveles de detalle y el
refinamiento.

GEANT4 ofrece importantes ventajas sobre otros paquetes de simulación, tales como MCNP2,
EGS3, o de Fluka4, también utilizado en el HEP y comunidades de la física nuclear. Estos incluyen
la capacidad de manejar las geometrías más complejas y realistas, la cobertura de la mayoría de la
física conocida los procesos para todo tipo de partículas elementales y los núcleos necesarios para
la simulación del detector, la disponibilidad de varios modelos de la física de alternativas que
permitan al usuario elegir entre ellos basados en sus necesidades de precisión y velocidad,
facilidad de adaptación a los marcos de los usuarios de software, y extensión fácil por los usuarios
de acuerdo a sus necesidades particulares.

GUIA DE INSTALACIÓN DEL GEANT4


A continuación daremos los pasos a seguir para la instalación de GEANT4.

Instalaleremos la versiòn geant4.9.2.p01 para Linux en este caso sobre Ubuntu 9.04

PASO Nº1 (GCC)

GCC es un compilador integrado del proyecto GNU para C, C++, Objective C y Fortran; es capaz de
recibir un programa fuente en cualquiera de estos lenguajes y generar un programa ejecutable
binario en el lenguaje de la máquina donde ha de correr. La sigla GCC significa "GNU Compiler
Collection". Originalmente significaba "GNU C Compiler"; todavía se usa GCC para designar una
compilación en C. G++ refiere a una compilación en C++.

Verificar que versiòn de gcc tiene para ello escriba en el terminal: gcc -v en el terminal te
indicara si esta o no instalado alguna versiòn gcc, si no esta instalado se tendra que intalar
alguna versiòn recomendados:

gcc 3.4.6 (para SLC4 o RedHat 4)

gcc 4.2.1 (para SLC5 o RedHat 5)

PASO Nº2 (C++)

C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup.
La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos
que permitan la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes
orientados a objetos, el C++ es un lenguaje híbrido.
Posteriormente se añadieron facilidades de programación genérica, que se sumó a los otros dos
paradigmas que ya estaban admitidos (programación estructurada y la programación orientada a
objetos). Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma.
Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los
fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.
Una particularidad del C++ es la posibilidad de redefinir los operadores (sobrecarga de operadores),
y de poder crear nuevos tipos que se comporten como tipos fundamentales.
El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado por
primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En
C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.

verificar si esta instalado librerias para c++ asi como g++

PASO Nº3 (OpenGL)

OpenGL (Open Graphics Library) es una especificación estándar que define una API multilenguaje
y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. La interfaz consiste en
más de 250 funciones diferentes que pueden usarse para dibujar escenas tridimensionales
complejas a partir de primitivas geométricas simples, tales como puntos, líneas y triángulos. Fue
1
desarrollada originalmente por Silicon Graphics Inc. (SGI) en 1992 y se usa ampliamente en CAD,
realidad virtual, representación científica, visualización de información y simulación de vuelo.
También se usa en desarrollo de videojuegos, donde compite con Direct3D en plataformas Microsoft
Windows.
Fundamentalmente OpenGL es una especificación, es decir, un documento que describe un conjunto
de funciones y el comportamiento exacto que deben tener. Partiendo de ella, los fabricantes de
hardware crean implementaciones, que son bibliotecas de funciones que se ajustan a los requisitos
de la especificación, utilizando aceleración hardware cuando es posible. Dichas implementaciones
deben superar unos tests de conformidad para que sus fabricantes puedan calificar su
implementación como conforme a OpenGL y para poder usar el logotipo oficial de OpenGL.

En este caso usaremos el visor OpenGL para lo cual se tendra que instalar las librerias necesarias
para su correcto funcionamiento.

Recomendaciones: se sugiere que se instale con sumo cuidado dichas librerias ya que algunas
desinstalan otras las cuales podrian producir algùn error en el sistema operativo por lo cual no
instalar dichas librerias.

Si desea pude utilizar otros visores como es el caso de VRML la cual conyeva a instalar sus
respectivas librerias. Recomendación no utilice dos visores o mas ya que podria generar conflictos.
PASO Nº4 (CLHEP)

CLHEP es un conjunto de bibliotecas de base relacionadas con el cálculo y manipulación de datos


teniendo presente las propiedades relacionadas con la física de partículas.

Crear una carpeta con el nombre CLHEP. Luego descargue el archivo clhep-2.0.4.2.tgz de
3.4 Mb que lo puede obtener de la siguiente dirección:

http://proj-clhep.web.cern.ch/proj-clhep/DISTRIBUTION/distributions/clhep2.0.4.2.tgz

Una vez descargado el archivo descomprima en la carpeta CLHEP antes creada. Obtendrá
la siguiente carpeta 2.0.4.2.

En el terminal escriba: cd CLHEP/2.0.4.2./CLHEP

Luego escriba en el terminal: ./configure --prefix /home/hovi/CLHEP

Obteniendo la siguiente respuestainicia con:

Finaliza con:
Luego de obtenido lo anterior, escriba en el terminal: make

Obteniendo la siguiente respuesta inicia con:

Making all in Units

make[1]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP/Units‘

Making all in Units

make[2]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi//CLHEP/2.0.4.2/CLHEP/Units/Units'

make all-am

make[3]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi//CLHEP/2.0.4.2/CLHEP/Units/Units'

make[3]: Nothing to be done for `all-am'.

make[3]:Leavingdirectory`/afs/slac.stanford.edu/home/hovi//CLHEP/2.0.4.2/CLHEP/Units/Units'

make[2]:Leavingdirectory`/afs/slac.stanford.edu/home/hovi//CLHEP/2.0.4.2/CLHEP/Units/Units'

Termina con:

make[1]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP' ./build-
clheplib Units Vector Evaluator GenericFunctions Geometry Random Matrix RandomObjects
RefCount Cast Exceptions rm -f libCLHEP-2.0.4.2.a liblist=`./getObjectList -static Units
Vector Evaluator GenericFunctions Geometry Random Matrix RandomObjects RefCount
Cast Exceptions`; \ ar cru libCLHEP-2.0.4.2.a $liblist; ranlib libCLHEP-2.0.4.2.a rm -f
libCLHEP-2.0.4.2.so liblist=`./getObjectList -shared Units Vector Evaluator GenericFunctions
Geometry Random Matrix RandomObjects RefCount Cast Exceptions`; \ g++ -O -ansi -
pedantic -Wall -D_GNU_SOURCE -g -O2 -o libCLHEP-2.0.4.2.so -shared -Wl,-
soname,libCLHEP-2.0.4.2.so $liblist -o libCLHEP-2.0.4.2.so ./build-header

make[1]:Leavingdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP'

Ahora escribir en el terminal: make install


Obtendrá una respuesta inicia con:

Making install in Units


make[1]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP/Units'
Making install in Units
make[2]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP/Units/Uni
ts‘
make[3]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP/Units/Uni
ts‘
make[3]: Nothing to be done for `install-exec-am'.

Termina con:

if test -f ClhepVersion.h; then \ echo " /usr/bin/install -c –m


644'ClhepVersion.h''/home/hovi/CLHEP/include/CLHEP/ClhepVersion.h'"; \ /usr/bin/install -c
-m644"ClhepVersion.h"/home/hovi/CLHEP/Include /CLHEP/ClhepVersion.h"; \
else :; fi /usr/bin/install -c -m 644
'ClhepVersion.h''/home/hovi/CLHEP/include/CLHEP/ClhepVersion.h'
make[2]: Nothing to be done for `install-data-am'.
make[2]: Leaving directory `/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP'
make[1]: Leaving directory `/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP‘

NOTA: Si esta todo correcto en la carpeta CLHEP aparecerá dos directorios con los
nombres include y lib.

PASO Nº5 (GEANT4)

Crear una carpeta con el nombre geant4. Luego descargue el archivo geant4.9.2.p01tgz
de 18 Mb que lo puede obtener de la siguiente dirección:

http://geant4.web.cern.ch/geant4/support/source/geant4.9.2.p01.tar.gz

una vez descargado el archivo descomprima en la carpeta geant4, antes creada. Obtendrá
la siguiente carpeta geant4.9.2.p01

PASO Nº6 (data)

Ahora crear una carpeta con el nombre data dentro de /home/hovi/geant4/geant4.9.2.p01.


Luego descargue el archivo de datos de procesos electromagneticos de bajas energias de
8 Mb que lo puede obtener de la siguiente dirección:

http://geant4.web.cern.ch/geant4/support/source/G4EMLOW.6.2.tar.gz

una vez descargado el archivo descomprima en la carpeta data, antes creada.

PASO Nº7

Por medio del terminal ingrese a la carpeta geant4.9.2.p01 es decir:


cd /home/hovi/geant4/geant4.9.2.p01
luego vuelva a escribir en el terminal: ./Configure –build
se mostrara el siguiente mensaje en la cual se le pedirá que conteste una serie de
preguntas, como en este caso usaremos el visor OpenGL daremos

Especificar donde se instalo CLHEP


/home/hovi/CLHEP
Cuando pregunte:
G4VIS_BUILD_OPENGLX_DRIVER
G4VIS_USE_OPENGLX
responder: Y
cuando pregunte
G4VIS_BUILD_RAYTRACERX_DRIVER
G4VIS_USE_RAYTRACERX
responder: Y
NOTA: para el resto de las preguntas acepte las respuestas que se indican por defecto.
luego vuelva a escribir en el terminal:

./Configure –build
luego vuelva a escribir en el terminal: ./Configure –install
(genera los scrips: env.csh . env.sh)

luego vuelva a escribir en el terminal: ./Configure

Ahora procedemos a ejecutar uno de los ejemplos para ello realizamos lo siguiente:
Termina en:

Ahora ingresamos a la carpeta del ejemplo copiado en la zona de trabajo G4WORK


luego escribimos make
Termina en:

Ahora escribimos: vis/open OGLIX

Aparecerá un mensaje

Ahora escribimos: vis/drawVolume

Aparecerá un mensaje

Ahora escribimos: vis/scene/add/trayectories

Aparecerá un mensaje

Ahora escribimos: vis/scene/add/hits

Aparecerá un mensaje

Ahora escribimos: run/veamOm 4

Tal como se muestra en la siguiente imagen


Mostrara los resultados obtenidos tal como se muestra en la grafica
Se observara

Digitamos un comando tal como se ve en la imagen para girar y ver mejor, obteniendo
Se obtendrá

Otro angulo
Bueno eso es todo referente a la instalación del GEANT4 con su respectivo ejemplo de prueba
para ver si todo a sido instalado de forma correcta.

Por algún motivo no se lograra obtener lo antes expuesto se sugiere visitar las siguientes páginas
donde se presentan otras alternativas de instalación.

http://geant4.kek.jp/g4users/g4space5/

http://www-geant4.kek.jp/g4users/g4tut07/install-win.html
Geant4 - Aplicación

La siguiente aplicación está basado en el tutorial, que se realizo en el Fermilab (octubre


27-29, 2003) disponible en el siguiente link:

http://conferences.fnal.gov/g4tutorial/

A continuación vamos a desarrollar los ejercicios 1,2 y 3 de este tutorial.

1. Geometría.
Antes de comenzar describimos algunas características del ejemplo escogido.

Espectómetro de doble brazo con cámaras de deriva, hodoscope y calorímetros.

Un brazo proporciona información de posición y el momento de la partícula incidente,


mientras que el otro recoge información de la posición, el tiempo y energía de la partícula
después de haber sido desviada por un campo magnético en el centro del espectrómetro.

Este ejemplo utiliza la física de los procesos siguientes:


Electromagnética: efecto foto-eléctrico, Dispersión de Compton, producción de pares,
bremsstrahlung, ionización, dispersión múltiple, aniquilación.

Decaimiento.

Transporte en un campo.

Se definen las partículas: geantino, gamma, leptones, piones, muones.

Materiales.

Hodoscope, conjunto de centelladores(C,H)

Camara de deriva – gas de argon.

Calorimetro EM – cristales de CsI

Calorimetro hadronico – Plomo y centelladores.

En el ejercicio 1, tenemos el código incompleto, que al compilarlo y ejecutarlo tenemos:

Es decir solo tenemos el primer brazo del espectrómetro. Que consiste en una caja con
aire, Hodoscope (15 centelladores verticales) y la cámara de deriva (5 capas de gas Argón
con una placa en el centro de cada capa).

 El primer paso es agregar el campo magnético.


Dado en la clase A01MagneticField. y la clase A01MagneticFieldMessenger. permite
cambiar el valor del campo desde terminal mediante G4UImessenger .
A01MagneticField deriva de G4MagneticField . El método GetFieldvalue da el valor del
campo.
Luego agregamos G4FieldManager y G4TransportationManager en
A01Detectorconstruction

Parte de A01MagneticField.cc
void A01MagneticField::GetFieldValue(const double Point[3],double *Bfield) const
{
Bfield[0] = 0.;
Bfield[2] = 0.;
if(std::abs(Point[1])<ymax && (sqr(Point[0])+sqr(Point[2]))<rmax_sq)
{ Bfield[1] = By; }
else
{ Bfield[1] = 0.; }
}

Parte A01Detectorconstruction.cc
#include "G4FieldManager.hh"
#include "G4TransportationManager.hh"
#include "A01MagneticField.hh“
A01DetectorConstruction::A01DetectorConstruction()
: air(0), argonGas(0), scintillator(0),

{ messenger = new A01DetectorConstMessenger(this);
magneticField = new A01MagneticField();

A01DetectorConstruction::~A01DetectorConstruction()
{ delete magneticField;
delete armRotation;
...
// campo magnetico
static G4bool fieldIsInitialized = false;
if(!fieldIsInitialized)
{ G4FieldManager* fieldMgr =
G4TransportationManager::GetTransportationManager()->GetFieldManager();
fieldMgr->SetDetectorField(magneticField);
fieldMgr->CreateChordFinder(magneticField);
fieldIsInitialized = true;
}

Con el cual hemos agregado el campo magnético.


 Agregamos el Hodoscopo (centelladores)
Primero definimos los materiales (Plomo, Iodo, Cesio)
Parte A01Detectorconstruction.cc
// Definimos los materiales -plomo
a= 2007.19*g/mole;
density = 11.35*g/cm3;
plomo = new G4Material(name="Plomo" , z=82. , a, density);
//CsI
a= 126.9*g/mole;
G4Element* elI = new G4Element(name="Iodo" , symbol="I", z=53. , a);
a= 132.9*g/mole;
G4Element* elCs = new G4Element(name="Cesio" ,symbol="Cs", z=55. ,a);
density= 4.51*g/cm3;
CsI = new G4Material(name ="CsI" , density, nElem=2);
CsI-> AddElement (elI, weightRatio=.5);
CsI-> AddElement(elCs, weightRatio=.5);
G4cout << G4endl << "The materials defined are : " << G4endl << G4endl;
G4cout << *(G4Material::GetMaterialTable()) << G4endl;

El cual nos la salida.


En A01Detectorconstruction.hh definimos los punteros a G4Material plomo y CsI.
Inicializamos en cero ( Cs(0), plomo(0) ) en A01Detectorconstruction.cc

Parte A01Detectorconstruction.cc

//hodoscopes en el segundo brazo


G4VSolid* hodoscope2Solid = new
G4Box("hodoscope2Caja",5.*cm,20.*cm,0.5*cm);
G4LogicalVolume* hodoscope2Logical
= new
G4LogicalVolume(hodoscope2Solid,scintillator,"hodoscope2Logical",0,0,0);
for(int i2=0;i2<25;i2++)
{
G4double x2 = (i2-12)*10.*cm;
new G4PVPlacement(0,G4ThreeVector(x2,0.,0.),hodoscope2Logical,
"hodoscope2Physical",secondArmLogical,0,i2);
}
 Agregamos la cámara de deriva.
Cámaras de 3m de ancho, 60cm de altura y 2cm de espesor, con placas en el
centro de 2mm de espesor.

Parte A01Detectorconstruction.cc

G4VSolid* camara2Solid = new G4Box("camara2Box", 1.5*m, 30.*cm, 1.*cm);


G4LogicalVolume* camara2Logical = new G4LogicalVolume(camara2Solid,
argonGas, "camara2Logical",0,0,0);
for(int j2=0;j2<9;j2++)
{
G4double z2= (j2-4)*0.25*m - 1.5*m ;
new
G4PVPlacement(0,G4ThreeVector(0.,0.,z2),camara2Logical,"camara2Phisico",secon
dArmLogical,0,j2);
}
G4VSolid* placa2Solid = new G4Box("placa2caja",1.5*m,30.*cm,0.1*mm);
G4LogicalVolume* placa2Logical = new
G4LogicalVolume(placa2Solid,argonGas,"placa2Logical",0,0,0);
new
G4PVPlacement(0,G4ThreeVector(0.,0.,0.),placa2Logical,"placa2Physical",camara2L
ogical,0,0);

 Agregamos el calorímetro electromagnético.


El calorímetro es un arreglo de 20x4 de estos cristales. Cristales de 15cm de
ancho, 15cm de altura y 30cm de espesor.
Parte A01Detectorconstruction.cc
G4VSolid* EMcalorimetroSolid = new
G4Box("EMCajaCalorimetro",1.5*m,30.*cm,15.*cm);
G4LogicalVolume* EMcalorimetroLogical = new
G4LogicalVolume(EMcalorimetroSolid,CsI,"EMcalorimetroLogical",0,0,0);
new G4PVPlacement(0,G4ThreeVector(0.,0.,2.*m),EMcalorimetroLogical,
"EMcalorimetroPhysical", secondArmLogical,0,0);
//celdas calorimetro EM
G4VSolid* celdaSolid = new G4Box("celdaCaja", 7.5*cm, 7.5*cm,15.*cm);
G4LogicalVolume* celdaLogical
= new G4LogicalVolume(celdaSolid, CsI,"celdaLogical",0,0,0);
G4VPVParameterisation* celdaParam = new A01CellParameterisation();
new G4PVParameterised("celdaPhysical",
celdaLogical,EMcalorimetroLogical,kXAxis,80,celdaParam);

parte de A01CellParameterisation.cc

A01CellParameterisation::A01CellParameterisation()
{
for(int copyNo=0;copyNo<80;copyNo++)
{ G4int column = copyNo / 4;
G4int row = copyNo % 4;
xCell[copyNo] = (column-9)*15.*cm - 7.5*cm;
yCell[copyNo] = (row-1)*15*cm - 7.5*cm;
}
}
A01CellParameterisation::~A01CellParameterisation()
{;}
void A01CellParameterisation::ComputeTransformation
(const G4int copyNo,G4VPhysicalVolume *physVol) const
{
physVol->SetTranslation(G4ThreeVector(xCell[copyNo],yCell[copyNo],0.));
}
 Agregamos el calorímetro Hadrónico.
Sándwiches de plomo y centellador de 30cm de ancho, 30cm de altura y 5cm de
espesor. Colocados en un arreglo de 3m de ancho, 60cm de altura y 1m de
espesor.
Parte A01Detectorconstruction.cc

G4VSolid* CalorimetroHadSolid = new


G4Box("HadCalorimetroCaja",1.5*m,30.*cm,50.*cm);
G4LogicalVolume* CalorimetroHadLogical = new
G4LogicalVolume(CalorimetroHadSolid,lead,"CalorimetroHadLogical",0,0,0);
new
G4PVPlacement(0,G4ThreeVector(0.,0.,3.*m),CalorimetroHadLogical,"CalorimetroH
adphysical",secondArmLogical,0,0);
//columnas calorimetro hadronico
G4VSolid* ColumCalHadSolid = new
G4Box("ColumCalHadCaja",15.*cm,30.*cm,50.*cm);
G4LogicalVolume* ColumCalHadLogical = new
G4LogicalVolume(ColumCalHadSolid,lead,"CalorimetroHadLogical",0,0,0);
new
G4PVReplica("ColumCalHadPhysical",ColumCalHadLogical,CalorimetroHadLogical,kX
Axis,10,30.*cm);
//celda calorimetro hadronico
G4VSolid* CelCalHadSolid = new G4Box("CelCalHadCaja",15.*cm,30.*cm,50.*cm);
G4LogicalVolume* CelCalHadLogical
= new G4LogicalVolume(CelCalHadSolid,lead,"CelCalHadLogical",0,0,0);
new G4PVReplica("CelCalHadPhysical",CelCalHadLogical,
ColumCalHadLogical,kYAxis,2,30.*cm);
//nivel colorimetro hadronico
G4VSolid* CapaCalHadSolid
= new G4Box("CapaCalHadCaja",15.*cm,15.*cm,2.5*cm);
G4LogicalVolume* CapaCalHadLogical
= new G4LogicalVolume(CapaCalHadSolid,lead,"CapaCalHadLogical",0,0,0);
new G4PVReplica("CapaCalHadPhysical",CapaCalHadLogical,
CelCalHadLogical,kZAxis,20,5.*cm);
//plano centillador
G4VSolid* CentiCalHadSolid
= new G4Box("CentiCalHadCaja",15.*cm,15.*cm,0.5*cm);
G4LogicalVolume* CentiCalHadLogical
= new
G4LogicalVolume(CentiCalHadSolid,scintillator,"CentiCalHadLogical",0,0,0);
new G4PVPlacement(0,G4ThreeVector(0.,0.,2.*cm),CentiCalHadLogical,
"CentiCalHadPhysical",CapaCalHadLogical,0,0);
2. Partículas.
Geant4 posee varios tipos de partículas para simulación, cada partícula representado por
su propia clase que deriva de G4ParticleDefinition. Las partículas son organizados en 6
categorías: leptones, mesones, bariones, bosones, de vida-corta e iones.

Los procesos físicos describen como interactúan las partículas con el material tenemos 7
categorías principales de procesos: electromagnetico, hadrónico, decaimiento, fotolepton-
hadron, ópticos, parametrización y de transporte.

Cada proceso tiene dos grupos de métodos que desempeñan un papel importante en el
seguimiento, GetPhysicalInteractionLength (GPIL) y DoIt. El método de GPIL da la longitud
del paso desde el punto espacio – tiempo actual a el punto espacio-tiempo siguiente .Esto
se hace mediante el cálculo de la probabilidad de interacción basado en la información la
sección transversal del proceso.. Al final de este paso, el método DoIt debe invocarse El
método de DoIt implementa los detalles de la interacción, el cambio de energía de la
partícula, el impulso, dirección y posición, y la producción secundaria si es necesario.
Estos cambios se registran como objetos G4VParticleChange

 Geantino.
Esta partícula fue inventado para la simulación en Geant4, no interactúa con la
materia , solo es necesario el proceso de transporte.
 Positrón.
Para incluir la física electromagnética , incluimos A01EMPhysics.hh en
A01EMPhysicsList.
Se desvía en el campo y produce una lluvia de cargas en el calorímetro EM.
Procesos: dispersión múltiple, bremsstrahlung e, ionización ,aniquilación e+.

 Muones.
Incluir en A01EMPhysicsList.cc , A01MuonPhysics.hh
Ioniza el aire produciendo cargas negativas(rojo)
Procesos: dispersión múltiple , bremsstrahlung mu, ionización de mu, producción
de pares e + e- por muones
 Pion.
Agregamos física hidrómica (A01HadronPhysics.hh y A01HadronPhysics.cc)
El pion se desintegra en muon y neutrino en la primera cámara de deriva.
Procesos: Hadron elástica ,Hadron inelástica ,captura y fisión de neutrones
,aniquilación en reposo para anti-protones y anti-neutrones , scattering múltiple
para hadrones cargados, ionización de hadrones cargados .

3. Sensibilidad.
Hit es la interacción física instantánea en la trayectoria de la partícula o
acumulación de interacciones en la región sensible del detector.
La región sensible del detector crea hits usando la información dado en el objeto
G4Step y almacenados en G4Event al final de un evento.
El usuario define su clase hit derivado de G4VHit, pudiendo almacenar varios tipos
de información en esta clase como: posición y tiempo de paso, momento y energía
de la trayectoria, energia de deposición, información geométrica y combinaciones
de estos.
Los objetos de una clase hit deben ser almacenados en una colección, el cual es
una instancia de G4THitsCollection template class.
La colección hits son accesibles a través de G4Event al final de un evento, para
ser usado en el análisis del evento, y a través de G4SDManager durante el
proceso del evento, que se utiliza para el filtrado del evento.

Hodoscope y cámara de deriva

Parte de A01DetectorConstruction.cc

G4VPhysicalVolume* A01DetectorConstruction::Construct()
{
//
G4VSensitiveDetector* hodoscope1;
G4VSensitiveDetector* chamber1;
G4VSensitiveDetector* hodoscope2;
G4VSensitiveDetector* camara2;
G4SDManager* SDman = G4SDManager::GetSDMpointer();
G4String SDname;
hodoscope1 = new A01Hodoscope(SDname="/hodoscope1");
SDman->AddNewDetector(hodoscope1);
hodoscope1Logical->SetSensitiveDetector(hodoscope1);

hodoscope2 = new A01Hodoscope(SDname="/hodoscope2");


SDman->AddNewDetector(hodoscope2);
hodoscope2Logical->SetSensitiveDetector(hodoscope2);
chamber1 = new A01DriftChamber(SDname="/chamber1");
SDman->AddNewDetector(chamber1);
wirePlane1Logical->SetSensitiveDetector(chamber1);
camara2 = new A01DriftChamber(SDname="/camara2");
SDman->AddNewDetector(camara2);
wirePlane2Logical->SetSensitiveDetector(camara2);

Parte de A01EvenAction.cc

A01EventAction::A01EventAction()
{
G4String colName;
G4SDManager* SDman = G4SDManager::GetSDMpointer();
HHC1ID = SDman->GetCollectionID(colName="hodoscope1/hodoscopeColl");
DHC1ID = SDman->GetCollectionID(colName="chamber1/driftChamberColl");
//colocando ID
HHC2ID = SDman->GetCollectionID(colName="hodoscope2/hodoscopeColl");
DHC2ID = SDman->GetCollectionID(colName="camara2/driftChamberColl");
void A01EventAction::EndOfEventAction(const G4Event* evt)
{
G4HCofThisEvent * HCE = evt->GetHCofThisEvent();
A01HodoscopeHitsCollection* HHC1 = 0;
A01DriftChamberHitsCollection* DHC1 = 0;
//...
A01HodoscopeHitsCollection* HHC2 = 0;
A01DriftChamberHitsCollection* DHC2 = 0;
//....
A01EmCalorimeterHitsCollection* ECHC = 0;
A01HadCalorimeterHitsCollection* HCHC = 0;
if(HCE)
{
HHC1 = (A01HodoscopeHitsCollection*)(HCE->GetHC(HHC1ID));
DHC1 = (A01DriftChamberHitsCollection*)(HCE->GetHC(DHC1ID));
//...
HHC2 = (A01HodoscopeHitsCollection*)(HCE->GetHC(HHC2ID));
DHC2 = (A01DriftChamberHitsCollection*)(HCE->GetHC(DHC2ID));
//....
ECHC = (A01EmCalorimeterHitsCollection*)(HCE->GetHC(ECHCID));
HCHC = (A01HadCalorimeterHitsCollection*)(HCE->GetHC(HCHCID));
}
...
//
if(HHC2)
{ int n_hit = HHC2->entries();
G4cout << "Hodoscope 2 tiene " << n_hit << " colisiones." << G4endl;
for(int i1=0;i1<n_hit;i1++)
{
A01HodoscopeHit* aHit = (*HHC2)[i1];
aHit->Print();
}
}
}
//
if(DHC2)
{
int n_hit = DHC2->entries();
G4cout << "Camara de deriva 2 tiene " << n_hit << " colisiones." << G4endl;
for(int i2=0;i2<5;i2++)
{
for(int i1=0;i1<n_hit;i1++)
{
A01DriftChamberHit* aHit = (*DHC2)[i1];
if(aHit->GetLayerID()==i2) aHit->Print();
}
}
}

Salida.
>>> Event 0 >>> Simulation truth : e+ (-4.615962429507,0,989.29283496844)
Hodoscope 1 has 1 hits.
Hodoscope[7] 4.9868571910584 (nsec)
Hodoscope 2 tiene 1 colisiones.
Hodoscope[8] 43.07777699026 (nsec)
Drift Chamber 1 has 6 hits.
Layer[0] : time 6.6711038083754 (nsec) --- local (x,y) -12.964912979212, -0.039498654249376
Layer[1] : time 8.3390095958199 (nsec) --- local (x,y) -17.974093214733, -0.68236328588736
Layer[2] : time 10.006909835187 (nsec) --- local (x,y) -22.798176055634, -1.4412423578075
Layer[3] : time 11.674807992901 (nsec) --- local (x,y) -27.5507927848, -2.2321515445323
Layer[3] : time 12.332190636356 (nsec) --- local (x,y) -6.0281819661482, -86.553137480673
Layer[4] : time 13.342699048469 (nsec) --- local (x,y) -32.01375154174, -3.297089404578
Camara de deriva 2 tiene 5 colisiones.
Layer[0] : time 34.737886998822 (nsec) --- local (x,y) -224.55971729671, -23.354142901273
Layer[1] : time 36.409114104763 (nsec) --- local (x,y) -256.50456338376, -24.689009720259
Layer[2] : time 38.080321993001 (nsec) --- local (x,y) -288.35526777196, -26.116257650382
Layer[3] : time 39.751583993649 (nsec) --- local (x,y) -320.45799915737, -27.582919723848
Layer[4] : time 41.422867626714 (nsec) --- local (x,y) -352.647703604, -29.33252167976

Calorímetro EM y Hadrónico.
Parte de A01HadCalorimeter.cc
A01HadCalorimeter::A01HadCalorimeter(G4String name)
:G4VSensitiveDetector(name)
{
//definimos coleccion de hits
G4String HCname;
collectionName.insert(HCname="HadCalorimeterColl");
HCID = -1;
}
void A01HadCalorimeter::Initialize(G4HCofThisEvent*HCE)
{ //inicializacion
hitsCollection = new A01HadCalorimeterHitsCollection
(SensitiveDetectorName,collectionName[0]);
if(HCID<0)
{ HCID = G4SDManager::GetSDMpointer()->GetCollectionID(hitsCollection); }
HCE->AddHitsCollection(HCID,hitsCollection);
// llenado de las colisiones del calorimetro con energia cero.
for(int iColumn=0;iColumn<10;iColumn++)
for(int iRow=0;iRow<2;iRow++)
{
A01HadCalorimeterHit* aHit = new A01HadCalorimeterHit();
hitsCollection->insert( aHit );
}
}
G4bool A01HadCalorimeter::ProcessHits(G4Step*aStep,G4TouchableHistory* )
{//....
G4double edep = aStep->GetTotalEnergyDeposit();
if(edep==0.) return true;
G4StepPoint* preStepPoint = aStep->GetPreStepPoint();
G4TouchableHistory* theTouchable
= (G4TouchableHistory*)(preStepPoint->GetTouchable());
G4VPhysicalVolume* theCellPhysical = theTouchable->GetVolume(2);
G4int rowNo = theCellPhysical->GetCopyNo();
G4VPhysicalVolume* theColumnPhysical = theTouchable->GetVolume(3);
G4int columnNo = theColumnPhysical->GetCopyNo();
G4int hitID = 2*columnNo+rowNo;
A01HadCalorimeterHit* aHit = (*hitsCollection)[hitID];
// agregar energia de depsicion
aHit->AddEdep(edep);
// check if it is first touch....
if(aHit->GetColumnID()<0)
{aHit->SetColumnID(columnNo);
aHit->SetRowID(rowNo);
G4int depth = theTouchable->GetHistory()->GetDepth();
G4AffineTransform aTrans = theTouchable->GetHistory()->GetTransform(depth-
2);
aTrans.Invert();
aHit->SetRot(aTrans.NetRotation());
aHit->SetPos(aTrans.NetTranslation());
} return true;
}
Parte de A01DetectorConstruction.cc
G4VPhysicalVolume* A01DetectorConstruction::Construct()
{// All managed (deleted) by SDManager
G4VSensitiveDetector* hodoscope1;
G4VSensitiveDetector* chamber1;
G4VSensitiveDetector* hodoscope2;
G4VSensitiveDetector* camara2;
G4VSensitiveDetector* calorimetroEM;
G4VSensitiveDetector* calorimetroHad;
ConstructMaterials();
...
//sensibilidad del calorimetro EM y Had
calorimetroEM = new A01EmCalorimeter(SDname="/calorimetroEM");
SDman->AddNewDetector(calorimetroEM);
cellLogical->SetSensitiveDetector(calorimetroEM);
calorimetroHad = new A01HadCalorimeter(SDname="/calorimetroHad");
SDman->AddNewDetector(calorimetroHad);
HadCalScintiLogical->SetSensitiveDetector(calorimetroHad);

Parte de A01EvenAction.cc
void A01EventAction::EndOfEventAction(const G4Event* evt)
{G4HCofThisEvent * HCE = evt->GetHCofThisEvent();
A01HodoscopeHitsCollection* HHC1 = 0;
A01DriftChamberHitsCollection* DHC1 = 0;
A01HodoscopeHitsCollection* HHC2 = 0;
A01DriftChamberHitsCollection* DHC2 = 0;
//....
A01EmCalorimeterHitsCollection* ECHC = 0;
A01HadCalorimeterHitsCollection* HCHC = 0;
if(HCE)
{HHC1 = (A01HodoscopeHitsCollection*)(HCE->GetHC(HHC1ID));
DHC1 = (A01DriftChamberHitsCollection*)(HCE->GetHC(DHC1ID));
HHC2 = (A01HodoscopeHitsCollection*)(HCE->GetHC(HHC2ID));
DHC2 = (A01DriftChamberHitsCollection*)(HCE->GetHC(DHC2ID));
//....
ECHC = (A01EmCalorimeterHitsCollection*)(HCE->GetHC(ECHCID));
HCHC = (A01HadCalorimeterHitsCollection*)(HCE->GetHC(HCHCID));
}
if(ECHC)
{ int iHit = 0;
double totalE = 0.;
for(int i1=0;i1<80;i1++)
{A01EmCalorimeterHit* aHit = (*ECHC)[i1];
double eDep = aHit->GetEdep();
if(eDep>0.)
{iHit++;
totalE += eDep; }
}
G4cout << "Calorimetro EM tiene " << iHit << " colisiones. Total de Edep es " <<
totalE/MeV << " (MeV)" << G4endl;
}
if(HCHC)
{int iHit = 0;
double totalE = 0.;
for(int i1=0;i1<20;i1++)
{A01HadCalorimeterHit* aHit = (*HCHC)[i1];
double eDep = aHit->GetEdep();
if(eDep>0.)
{ iHit++;
totalE += eDep; }
}
G4cout << "Calorimetro Hadronico tiene " << iHit << " colisiones. Total de Edep
es "<< totalE/MeV << " (MeV)" << G4endl; }
}
Salida.

>>> Event 0 >>> Simulation truth : e+ (-46.608796284877,0,9989.1948678744)


Hodoscope 1 has 1 hits.
Hodoscope[7] 4.9868392083869 (nsec)
Hodoscope 2 tiene 1 colisiones.
Hodoscope[9] 43.118621962955 (nsec)
Drift Chamber 1 has 5 hits.
Layer[0] : time 6.6710266335687 (nsec) --- local (x,y) -9.6803244995177, -0.022961927981725
Layer[1] : time 8.3388694462032 (nsec) --- local (x,y) -12.266712177533, -0.10238247445638
Layer[2] : time 10.006712426243 (nsec) --- local (x,y) -14.862827971551, -0.18045061768859
Layer[3] : time 11.674555380763 (nsec) --- local (x,y) -17.457833952939, -0.2422246088771
Layer[4] : time 13.34239750811 (nsec) --- local (x,y) -20.004972727609, -0.29014202087488
Camara de deriva 2 tiene 8 colisiones.
Layer[0] : time 34.782064077075 (nsec) --- local (x,y) -184.26271026763, -1.2616713099189
Layer[1] : time 36.452645892551 (nsec) --- local (x,y) -213.04660965888, -1.2832391910433
Layer[2] : time 38.123231045669 (nsec) --- local (x,y) -241.84791896898, -1.2889280136141
Layer[2] : time 38.374680336176 (nsec) --- local (x,y) -148.7895788798, 13.368171076805
Layer[2] : time 40.25655731369 (nsec) --- local (x,y) 247.34773628013, 149.34457425109
Layer[2] : time 41.766655754835 (nsec) --- local (x,y) 386.00350941469, 254.73904448587
Layer[3] : time 39.79382044807 (nsec) --- local (x,y) -270.6713482343, -1.2522298797379
Layer[4] : time 41.464407407445 (nsec) --- local (x,y) -299.4820409237, -1.2075098221661
Calorimetro EM tiene 17 colisiones. Total de Edep es 9593.7519690313 (MeV)
Calorimetro Hadronico tiene 2 colisiones. Total de Edep es 3.347249882462 (MeV)
Idle> gun/particle proton
Idle> run/beamOn 1
>>> Event 0 >>> Simulation truth : proton (-24.860054213226,0,10017.118355756)
Hodoscope 1 has 2 hits.
Hodoscope[7] 5.008630250396 (nsec)
Hodoscope[13] 6.4100617879675 (nsec)
Hodoscope 2 tiene 1 colisiones.
Hodoscope[9] 43.340078743539 (nsec)
Drift Chamber 1 has 5 hits.
Layer[0] : time 6.700176378978 (nsec) --- local (x,y) -5.1183167816382, 0.009114904954258
Layer[1] : time 8.3753064279533 (nsec) --- local (x,y) -6.3389177805586, 0.012143046731096
Layer[2] : time 10.050436548432 (nsec) --- local (x,y) -7.5509602398323, 0.0072864347224467
Layer[3] : time 11.725566866727 (nsec) --- local (x,y) -8.7739975034423, 0.0023298499659164
Layer[4] : time 13.40069757257 (nsec) --- local (x,y) -10.022792328185, -0.025842586251126
Camara de deriva 2 tiene 5 colisiones.
Layer[0] : time 34.966983005503 (nsec) --- local (x,y) -164.71958608517, -0.6706775751057
Layer[1] : time 36.644891754846 (nsec) --- local (x,y) -193.54353351681, -0.6908194338258
Layer[2] : time 38.322799773489 (nsec) --- local (x,y) -222.36292543159, -0.71962802755192
Layer[3] : time 40.000708857268 (nsec) --- local (x,y) -251.18732150957, -0.72463658746971
Layer[4] : time 41.678613487695 (nsec) --- local (x,y) -279.98782294257, -0.72526568035024
Calorimetro EM tiene 23 colisiones. Total de Edep es 2660.7790862454 (MeV)
Calorimetro Hadronico tiene 4 colisiones. Total de Edep es 46.360669294988 (MeV)
Idle> /gun/particle pi+
Idle> run/beamOn 1
>>> Event 0 >>> Simulation truth : pi+ (-100.01578037668,0,10009.321970853)
Hodoscope 1 has 1 hits.
Hodoscope[7] 4.9875191754795 (nsec)
Hodoscope 2 tiene 2 colisiones.
Hodoscope[9] 43.058033207213 (nsec)
Hodoscope[8] 43.085932873146 (nsec)
Drift Chamber 1 has 5 hits.
Layer[0] : time 6.6719312979471 (nsec) --- local (x,y) -20.024890301602, 0.022300102668735
Layer[1] : time 8.3399967066626 (nsec) --- local (x,y) -25.005323481939, 0.016015943064595
Layer[2] : time 10.008061353803 (nsec) --- local (x,y) -29.96253176031, -0.01731869898438
Layer[3] : time 11.676125557418 (nsec) --- local (x,y) -34.906162693683, -0.060860781414065
Layer[4] : time 13.344190184267 (nsec) --- local (x,y) -39.862597955862, -0.082772181616971
Camara de deriva 2 tiene 5 colisiones.
Layer[0] : time 34.722308209234 (nsec) --- local (x,y) -214.64573319133, -0.65892891581623
Layer[1] : time 36.392725278052 (nsec) --- local (x,y) -241.6687448664, -0.77834267183107
Layer[2] : time 38.063144636993 (nsec) --- local (x,y) -268.70429106872, -0.92980235450965
Layer[3] : time 39.733563273723 (nsec) --- local (x,y) -295.73566446459, -1.1059736664348
Layer[4] : time 41.403983744721 (nsec) --- local (x,y) -322.77699078216, -1.3104826542075
Calorimetro EM tiene 13 colisiones. Total de Edep es 223.62332294036 (MeV)
Calorimetro Hadronico tiene 10 colisiones. Total de Edep es 180.89798770084 (MeV)
Idle> gun/particle mu+
Idle> run/beamOn 1
>>> Event 0 >>> Simulation truth : mu+ (19.091996847819,0,9995.58869582)
Hodoscope 1 has 1 hits.
Hodoscope[7] 4.9870690478664 (nsec)
Hodoscope 2 tiene 1 colisiones.
Hodoscope[9] 43.210911299625 (nsec)
Drift Chamber 1 has 6 hits.
Layer[0] : time 6.6713321466766 (nsec) --- local (x,y) 3.5731949397791, 0.24265023963362
Layer[1] : time 8.3392497281279 (nsec) --- local (x,y) 4.6120422311356, 0.51069100168785
Layer[2] : time 10.007167132624 (nsec) --- local (x,y) 5.6304440755348, 0.75378439758907
Layer[3] : time 11.67508459521 (nsec) --- local (x,y) 6.6573901237194, 0.99358949558899
Layer[4] : time 13.343001523032 (nsec) --- local (x,y) 7.431936008789, 1.368029997944
Layer[4] : time 13.357431738106 (nsec) --- local (x,y) 59.785817940045, -24.216671453576
Camara de deriva 2 tiene 5 colisiones.
Layer[0] : time 34.871246852893 (nsec) --- local (x,y) -144.25614381923, 6.5529674676622
Layer[1] : time 36.542450687345 (nsec) --- local (x,y) -175.67010865111, 6.9498349897422
Layer[2] : time 38.213660212294 (nsec) --- local (x,y) -207.11095730946, 7.3688477217281
Layer[3] : time 39.884862648778 (nsec) --- local (x,y) -238.51785871302, 7.7916414103438
Layer[4] : time 41.556077462969 (nsec) --- local (x,y) -269.9832192661, 8.2594004357906
Calorimetro EM tiene 4 colisiones. Total de Edep es 414.10963164764 (MeV)
Calorimetro Hadronico tiene 2 colisiones. Total de Edep es 114.56583443596 (MeV)
Idle> exit
REFERENCIAS
1. http://geant4.slac.stanford.edu/tutorial/installation/Geant4.9.2.p01/Linux/Geant4_9_2_p01_
Linux_Installation.htm

2. http://conferences.fnal.gov/g4tutorial/

3. http://geant4.web.cern.ch/geant4/UserDocumentation/UsersGuides/ForApplicationDevelope
r/html/index.html .