Simulación de Monte-Carlo de Cámaras de Placas Resistivas ...

Simulación de Monte-Carlo deCámaras de Placas Resistivas (RPC)para muones del experimento CMS

por

Andrés Leonardo Cabrera Mora

Una tesis

presentada al departamento

de Física

como parte de los requisitos

para el grado de

Físico

Director: Bernardo Gómez Moreno

Universidad de los Andes

Bogotá, Colombia

Mayo 15, 2008

i

Para el creador de todas las cosas: Jesús.

Andrés Leonardo Cabrera Mora.

Índice general

1. Introducción 1

2. El Gran Colisionador de Hadrones (Large Hadron Collider, LHC) 2

3. El Experimento CMS 7

4. Detectores de ionización 12

5. Cámaras de Placas resistivas 165.1. Modos de operación . . . . . . . . . . . . . . . . . . . . . . . . . . 175.2. Parámetro η: La seudorapidez . . . . . . . . . . . . . . . . . . . . 195.3. Principio de Operación . . . . . . . . . . . . . . . . . . . . . . . . 20

6. Simulación de una placa de aluminio 246.1. Simulación implementada . . . . . . . . . . . . . . . . . . . . . . 246.2. Resultados obtenidos . . . . . . . . . . . . . . . . . . . . . . . . . 26

7. Simulación de una RPC 367.1. Resultados obtenidos . . . . . . . . . . . . . . . . . . . . . . . . . 39

7.1.1. Incidencia de muones positivos . . . . . . . . . . . . . . . . 397.1.2. Incidencia de muones negativos . . . . . . . . . . . . . . . 437.1.3. Incidencia de gammas . . . . . . . . . . . . . . . . . . . . 43

7.2. Análisis de resultados . . . . . . . . . . . . . . . . . . . . . . . . . 43

8. Conclusiones 56

A. ¾Cómo instalar Geant4? 58A.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58A.2. Bajando los paquetes necesarios . . . . . . . . . . . . . . . . . . . 59A.3. Creando las carpetas de instalación . . . . . . . . . . . . . . . . . 60A.4. Instalando las librerías CLHEP . . . . . . . . . . . . . . . . . . . 62A.5. Descomprimiendo los archivos de Geant4 . . . . . . . . . . . . . . 66A.6. Descomprimiendo los archivos para procesos electromagnéticos de

baja energía . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

A.7. Instalando Geant4 . . . . . . . . . . . . . . . . . . . . . . . . . . 68A.8. Congurando el archivo fuente . . . . . . . . . . . . . . . . . . . . 72

B. ¾Cómo correr un ejemplo en Geant4? 74B.1. Creando el directorio de trabajo . . . . . . . . . . . . . . . . . . . 74B.2. Seleccionando una aplicación de ejemplo . . . . . . . . . . . . . . 74B.3. Congurando el ambiente de Geant4 . . . . . . . . . . . . . . . . 75B.4. Construyendo la aplicación de ejemplo . . . . . . . . . . . . . . . 76B.5. Corriendo el ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . 77

C. Manual de instalación del interfaz aida 81C.1. Bajando los paquetes necesarios . . . . . . . . . . . . . . . . . . . 81C.2. Creando la estructura de directorios . . . . . . . . . . . . . . . . . 82C.3. Descomprimiendo los instaladores . . . . . . . . . . . . . . . . . . 83C.4. Usando jas3 y java . . . . . . . . . . . . . . . . . . . . . . . . . . 84C.5. Usando jaida, aidajni y java . . . . . . . . . . . . . . . . . . . . . 84C.6. Corriendo un ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . 86

D. Clases implementadas para la simulación de la placa de aluminio 89D.1. Archivo Principal: pol01.cc . . . . . . . . . . . . . . . . . . . . . . 89D.2. Ejecutable: GNUmakele . . . . . . . . . . . . . . . . . . . . . . . 91D.3. Archivos contenidos en la carpeta src . . . . . . . . . . . . . . . . 92

D.3.1. DetectorConstruction.cc . . . . . . . . . . . . . . . . . . . 92D.3.2. DetectorMessenger.cc . . . . . . . . . . . . . . . . . . . . . 98D.3.3. EventAction.cc . . . . . . . . . . . . . . . . . . . . . . . . 99D.3.4. EventActionMessenger.cc . . . . . . . . . . . . . . . . . . . 100D.3.5. HistoManager.cc . . . . . . . . . . . . . . . . . . . . . . . 101D.3.6. HistoMessenger.hh . . . . . . . . . . . . . . . . . . . . . . 106D.3.7. PhysicsList.hh . . . . . . . . . . . . . . . . . . . . . . . . . 109D.3.8. PrimaryGeneratorAction.cc . . . . . . . . . . . . . . . . . 114D.3.9. RunAction.cc . . . . . . . . . . . . . . . . . . . . . . . . . 115D.3.10.StepMax.cc . . . . . . . . . . . . . . . . . . . . . . . . . . 120D.3.11.StepMaxMessenger.cc . . . . . . . . . . . . . . . . . . . . . 121D.3.12.SteppingAction.cc . . . . . . . . . . . . . . . . . . . . . . . 122

D.4. Archivos contenidos en la carpeta include . . . . . . . . . . . . . 124D.4.1. DetectorConstruction.hh . . . . . . . . . . . . . . . . . . . 124D.4.2. DetectorMessenger.hh . . . . . . . . . . . . . . . . . . . . 125D.4.3. EventAction.hh . . . . . . . . . . . . . . . . . . . . . . . . 126D.4.4. EventActionMessenger.hh . . . . . . . . . . . . . . . . . . 126D.4.5. HistoManager.hh . . . . . . . . . . . . . . . . . . . . . . . 127D.4.6. HistoMessenger.hh . . . . . . . . . . . . . . . . . . . . . . 129D.4.7. PhysicsList.hh . . . . . . . . . . . . . . . . . . . . . . . . . 130D.4.8. PrimaryGeneratorAction.hh . . . . . . . . . . . . . . . . . 131D.4.9. ProcessesCount.hh . . . . . . . . . . . . . . . . . . . . . . 131D.4.10.RunAction.hh . . . . . . . . . . . . . . . . . . . . . . . . . 132

iii

D.4.11.StepMax.hh . . . . . . . . . . . . . . . . . . . . . . . . . . 134D.4.12.StepMaxMessenger.hh . . . . . . . . . . . . . . . . . . . . 135D.4.13.SteppingAction.hh . . . . . . . . . . . . . . . . . . . . . . 135

E. Clases implementadas para la simulación de una RPC 137E.1. Archivo Principal: pol01.cc . . . . . . . . . . . . . . . . . . . . . . 137E.2. Ejecutable: GNUmakele . . . . . . . . . . . . . . . . . . . . . . . 139E.3. Archivos contenidos en la carpeta src . . . . . . . . . . . . . . . . 140

E.3.1. DetectorConstruction.cc . . . . . . . . . . . . . . . . . . . 140E.3.2. DetectorMessenger.cc . . . . . . . . . . . . . . . . . . . . 146E.3.3. ElectricFieldSetup.cc . . . . . . . . . . . . . . . . . . . . . 147E.3.4. EventAction.cc . . . . . . . . . . . . . . . . . . . . . . . 151E.3.5. EventActionMessenger.cc . . . . . . . . . . . . . . . . . . 152E.3.6. FieldMessenger.cc . . . . . . . . . . . . . . . . . . . . . . 153E.3.7. HistoManager.cc . . . . . . . . . . . . . . . . . . . . . . . 155E.3.8. HistoMessenger.cc . . . . . . . . . . . . . . . . . . . . . . 161E.3.9. PhysicsList.cc . . . . . . . . . . . . . . . . . . . . . . . . 163E.3.10. PrimaryGeneratorAction.cc . . . . . . . . . . . . . . . . . 171E.3.11. RunAction.cc . . . . . . . . . . . . . . . . . . . . . . . . 173E.3.12. StepCut.cc . . . . . . . . . . . . . . . . . . . . . . . . . . 177E.3.13. StepMax.cc . . . . . . . . . . . . . . . . . . . . . . . . . 178E.3.14. StepMaxMessenger.cc . . . . . . . . . . . . . . . . . . . . 179E.3.15. SteppingAction.cc . . . . . . . . . . . . . . . . . . . . . . 180

E.4. Archivos contenidos en la carpeta include . . . . . . . . . . . . . 182E.4.1. DetectorConstruction.hh . . . . . . . . . . . . . . . . . . . 182E.4.2. DetectorMessenger.hh . . . . . . . . . . . . . . . . . . . . 183E.4.3. ElectricFieldSetup.hh . . . . . . . . . . . . . . . . . . . . 184E.4.4. EventAction.hh . . . . . . . . . . . . . . . . . . . . . . . 185E.4.5. EventActionMessenger.hh . . . . . . . . . . . . . . . . . 186E.4.6. FieldMessenger.hh . . . . . . . . . . . . . . . . . . . . . . 187E.4.7. HistoManager.hh . . . . . . . . . . . . . . . . . . . . . . 188E.4.8. HistoMessenger.hh . . . . . . . . . . . . . . . . . . . . . 189E.4.9. PhysicsList.hh . . . . . . . . . . . . . . . . . . . . . . . . 190E.4.10. PrimaryGeneratorAction.hh . . . . . . . . . . . . . . . . 192E.4.11. ProcessesCount.hh . . . . . . . . . . . . . . . . . . . . . 193E.4.12. RunAction.hh . . . . . . . . . . . . . . . . . . . . . . . . 194E.4.13. StepCut.hh . . . . . . . . . . . . . . . . . . . . . . . . . 195E.4.14. StepMax.hh . . . . . . . . . . . . . . . . . . . . . . . . . 197E.4.15. StepMaxMessenger.hh . . . . . . . . . . . . . . . . . . . 198E.4.16. SteppingAction.hh . . . . . . . . . . . . . . . . . . . . . 199

Bibliografía 201

iv

Capítulo 1

Introducción

Este documento presenta los resultados de la simulación hecha con el código demonte Carlo Geant4 del paso de varios proyectiles (muones y gammas) a través deuna cámara de placas resistivas (RPC) como las que están siendo implementadasen el experimento CMS. El experimento CMS hace parte del Large Hadron Colli-der (LHC), un acelerador de partículas en donde se busca encontrar respuesta amuchas de las preguntas que han surgido del modelo actual que describe las par-tículas fundamentales que componen el universo y las interacciones entre ellas: Elmodelo estándar. Uno de sus principales objetivos es encontrar el bosón de Higgs,el cual sería un paso signicativo en la búsqueda de una gran teoría unicadorade las fuerzas fundamentales presentes en la naturaleza y con la cual también sepuede dar respuesta al origen de la masa. Para lograrlo el LHC utilizará variosdetectores, entre ellos el CMS; el cual es un detector de propósito general con elque se busca analizar la gran multitud de partículas producidas por las colisionesen el acelerador.

El CMS ha sido diseñado con varios subsistemas para medir energía y momen-to de los productos de las colisiones como fotones, electrones, muones, etc. Paraidenticar los muones y medir su momento el CMS empleará tres tipos de cáma-ras: los tubos de deriva, las cámaras catódicas y las cámaras de placas resistivas.Las cámaras RPC son detectores que proveen una señal rápida cuando un muónpasa a través de ellas generando que las otras dos cámaras sean disparadas. Laimportancia de la detección de muones en el CMS es para reconstruir los pro-ductos de las colisiones producidas en el detector, en este caso los muones. En eldocumento se presenta una descripción del LHC, del experimento CMS, y de lascámaras de placas resistivas, y como éstas se encuentran distribuidas en el CMS;también se describe el principio de funcionamiento de los detectores de ionización,en particular de una RPC.

Finalmente se realiza una simulación teniendo en cuenta la geometría quetienen las RPC en el CMS empleando el software Geant4 junto con el interfazAida para generar histogramas y scatter plots.

Capítulo 2

El Gran Colisionador de Hadrones

(Large Hadron Collider, LHC)

El LHC es un acelerador y colisionador de partículas localizado en el CERN

(Organización Europea para la Investigación Nuclear, el mayor laboratorio de

investigación en Física de partículas a nivel mundial), cerca de Ginebra. Este ace-

lerador funcionará a 271 grados centígrados bajo cero y empleará el túnel de 27

km de circunferencia creado para el Gran Colisionador de Electrones y Positrones

(LEP en inglés).

La principal meta de su diseño es encontrar la evasiva partícula conocida como

el bosón de Higgs. La vericación de la existencia del bosón de Higgs será un paso

signicativo en la búsqueda de una "Gran Teoría Unicadora", que busca la uni-

cación de las tres fuerzas fundamentales: El electromagnetismo, la fuerza nuclear

fuerte y la fuerza nuclear débil. El bosón de Higgs también ayudaría a explicar

por qué la gravitación es tan pequeña comparada con las otras tres fuerzas.

El colisionador está contenido en el túnel circular de 27 kilómetros de circunfe-

rencia y una profundidad de 50 a 175 metros bajo tierra. El túnel construido entre

1983 y 1988 fue hecho inicialmente para contener el LEP (Large Electron-Positron

Collider), un colisionador de electrones y positrones. El túnel de colisión contiene

dos tuberías encerradas con magnetos superconductores enfriados con helio líqui-

do, cada tubo contiene un rayo de protones. Los dos rayos viajan en direcciones

opuestas alrededor del anillo. Imanes adicionales son usados para dirigir los rayos

a cuatro puntos de intersección donde se darán las colisiones protón-protón. En

2.0 3

Figura 2.1: Esquema del LHC [2]

total hay instalados cerca de 1600 magnetos superconductores con peso aproxi-

mado de 27 toneladas. Se espera un cruce de haces de protones cada 25 ns con un

promedio de 20 colisiones por cruce [1].

Antes de ser inyectadas dentro del acelerador principal, las partículas son pre-

paradas a través de un serie de sistemas que incrementan sucesivamente su energía.

El primer sistema es el acelerador lineal (Linac 2) que genera protones de 50 MeV

(p en gura 2.1) que alimentan el PSB (Proton Synchrotron Booster). Después los

protones son inyectados a 1.4 GeV en el Proton Synchrotron (PS) que los acelera a

26 GeV. Luego son inyectados al SPS (Super Proton Synchrotron) que es emplea-

do para incrementar la energía de los protones por encima de los 450 GeV donde

nalmente ingresan al acelerador-colisionador LHC (Large Hadron Collider) en el

túnel de 27 km de circunferencia, donde cada haz de protones alcanza 7 TeV, para

un total de 14 TeV en la colisión frontal protón-protón.

El LHC también puede ser usado para colisionar iones pesados como plomo

(ZPb = 82) y la energía alcanzada será de 7 TeV por nucleón, lo que da 574 TeV

por ión de Pb y 1148 TeV como energía total en la colisión de los haces incidiendo

2.0 4

frontalmente. Los iones primero son acelerados con un acelerador lineal (Linac 3)

y se emplea el anillo inyector de baja energía (LEIR por sus siglas en ingles) como

unidad de almacenamiento y enfriamiento. Luego los iones son acelerados por el

PS y el PSP.

Seis detectores están siendo construidos en el LHC. Estos se encuentran loca-

lizados bajo tierra en grandes cavernas excavadas en los puntos donde los rayos

se interceptan. Dos de ellos son los experimentos grandes ATLAS y CMS, estos

se basan en detectores de propósitos generales para analizar la gran multitud de

partículas producto de las colisiones en el acelerador [3]. Estos detectores son

diseñados para investigar el mayor rango de física posible. Tener dos detectores

diseñados independientemente es vital para la reconrmación de cualquier nuevo

descubrimiento.

Hay dos experimentos medianos, ALICE y LHCb que tienen detectores espe-

cializados, en el caso de ALICE para analizar colisiones del LHC en relación a

fenómenos especícos como la búsqueda del plasma quark-gluón entre los pro-

ductos de la colisión de iones pesados, y en el caso de LHCb para el estudio de

procesos con violación de CP en decaimientos de partículas con el quark b, rela-

cionado con el desbalance observado entre materia y antimateria en el universo.

Los detectores ATLAS, CMS, ALICE y LHCb se encuentran instalados en

cuatro grandes cavernas bajo tierra en el anillo del LHC. Los detectores usados

por el experimento TOTEM se ubicarán cerca del experimento CMS, mientras

que el LHCf se encontrará cerca del experimento ATLAS.

El LHC ha sido construido para ayudar a los cientícos a resolver preguntas

clave en la física de partículas. La energía sin precedentes que puede alcanzar in-

cluso puede revelar algunos resultados inesperados en los cuales nadie ha pensado.

En las últimas décadas, los físicos han sido capaces de describir cada vez con

más detalle las partículas fundamentales que componen el Universo y las inter-

acciones entre ellas. Este conocimiento se encuentra encapsulado en el Modelo

Estándar de la física de partículas, pero no es toda la historia. Para llenar el

vacío que hace falta se requieren nuevos datos experimentales, este es el siguiente

2.0 5

gran paso a alcanzar con el LHC.

Algunas de las preguntas que se podrían resolver con los resultados obtenidos

por el LHC serían [[4],[5]]:

¾Qué es la masa? ¾Cuál es el origen de la masa? ¾Por qué las partículas pe-

queñas pesan lo que pesan? ¾Por qué algunas partículas no tienen masa? En el

presente no hay todavía una respuesta establecida a estas preguntas, la explicación

más probable la podemos encontrar en el bosón de Higgs, está es una partícula

que todavía no ha sido descubierta, pero que es esencial para que el modelo es-

tándar funcione. Fue propuesta por primera vez en 1984, pero todavía no ha sido

observada. Los experimentos ATLAS y CMS estarán buscando señales de esta

partícula tan esquiva.

Otra pregunta importante es ¾De qué está hecho el 96% del universo? Todo lo

que observamos en el universo, desde una hormiga hasta una galaxia se encuentra

hecho de partículas ordinarias, estas partículas son denominadas colectivamen-

te como materia, que forma aproximadamente el 4% del universo. La parte que

falta se cree que está hecha de materia y energía oscura, pero es muy difícil de

detectar y estudiar por otro medio que no sean las fuerzas gravitacionales que

ejerce. Investigar la naturaleza de la materia oscura y la energía oscura es uno

de los más grandes desafíos de hoy en la física de partículas y la cosmología. Los

experimentos ATLAS y CMS buscarán partículas supersimétricas para probar

una hipótesis probable para la composición de la materia oscura. De descubrirse

partículas supersimétricas se tendría la primera evidencia de la validez de la super-

simetría, que permite la gran unicación de la interacción fuerte con la interacción

electrodebil. Esta última, la interacción electrodebil, que es la unicación de las

interacciones electromagnética y débil ha sido comprobada ya experimentalmente.

También se busca resolver el favoritismo de la naturaleza, ¾Por qué no hay más

antimateria? Vivimos en un mundo de materia, todo lo que se encuentra en el uni-

verso, incluidos nosotros mismos, se encuentra hecho de materia. La antimateria

es como una hermana gemela de la materia, solo que con carga eléctrica opuesta.

En el nacimiento del universo, la misma cantidad de materia y antimateria debió

haber sido producida por el Big Bang. Pero cuando la materia y la antimateria se

unen se aniquilan transformándose en energía. Sin embargo una pequeña fracción

de materia debió de haber sobrevivido para formar el universo en el que vivimos

2.0 6

actualmente, quedando difícilmente algo de antimateria. ¾Por qué la naturaleza

tiene esta inclinación por la materia en lugar de antimateria?

El experimento LHCb buscará diferencias entre materia y antimateria para ayu-

darnos a resolver estas preguntas. Experimentos previos ya han observado diferen-

cias en el comportamiento, pero lo que se ha visto hasta ahora casi no es suciente

para tener en cuenta la cuestión de aparente desequilibrio materia-antimateria pre-

sente en el Universo.

Otro frente en el que se busca hallar respuesta es desentrañar los secretos del

Big Bang. ¾Cómo era la materia las primeras fracciones de segundos de vida del

universo? La materia de la que está hecha todo en el universo se cree que tuvo su

origen de una mezcla densa y caliente de partículas fundamentales. Hoy, la mate-

ria ordinaria del universo se encuentra hecha de átomos que contienen un núcleo

compuesto de protones y neutrones, que a su vez están hechos de quarks que se

encuentran enlazados entre sí por otras partículas llamadas gluones. Este enlace

es muy fuerte, pero en el universo temprano las condiciones debieron haber sido

demasiado energéticas como para que los gluones mantuvieran los quarks juntos,

en lugar de eso, parece probable que durante los primeros microsegundos después

del Big Bang el Universo tendría una mezcla densa y muy caliente de quarks y

gluones llamada plasma quark-gluón.

El experimento ALICE busca recrear condiciones similares a aquellas que se pro-

dujeron justo después del Big Bang, en particular para analizar las propiedades

del plasma quark-gluón. Otro de los aspectos en los que se busca profundizar es

¾en realidad existen dimensiones extra? Einstein mostró que las tres dimensio-

nes de espacio se encuentran relacionadas con el tiempo. Hay nuevas teorías que

proponen que pueden existir dimensiones espaciales ocultas, por ejemplo la teoría

de cuerdas propone que hay otras dimensiones espaciales que aún no se han ob-

servado. Estas dimensiones podrían llegar a ser detectables a muy altas energías,

por lo que los datos de todos los detectores serán analizados cuidadosamente para

buscar signos de otras dimensiones.

Capítulo 3

El Experimento CMS

Como lo había mencionando antes, el experimento CMS (Compact Muon So-

lenoid) es uno de los dos grandes detectores de propósito general diseñado para

explorar la física de la teraescala en energía.

El detector completo será cilíndrico con 21 metros de longitud, 16 metros de

diámetro y un peso aproximado de 12.500 toneladas. Los detectores del CMS que

se distribuyen en cilindros conforman el barril y los que están en las tapas confor-

man los endcaps [[1], [6]]. Este experimento se encuentra a 330 pies bajo tierra en

Cessy, Francia cerca de la frontera con Suiza [7].

El CMS contiene subsistemas que han sido diseñados para medir energía y

momento de fotones, electrones, muones y otros productos de las colisiones. La

capa más interna es un detector hecho a base de silicio, rodeando este detector se

encuentra el calorímetro electromagnético que es un cristal de centelleo, que a su

vez se encuentra rodeado por un calorímetro de muestreo para los hadrones. El

detector y los calorímetros son lo sucientemente compactos como para estar den-

tro del solenoide del CMS que genera un campo magnético de 4 Teslas. Alrededor

del solenoide encontramos los detectores de muones que se encuentran dentro del

yugo del solenoide.

Los principales objetivos del experimento son:

Explorar la física a la escala de Teraelectronvoltios.

3.0 8

Figura 3.1: Distribución del CMS [8]

Figura 3.2: Sección transversal del CMS [8]

3.0 9

Descubrir el bosón de Higgs.

Buscar evidencias de física más allá del modelo estándar, como suspersime-

tría, y dimensiones extra.

Estudiar aspectos de colisiones de iones pesados

En la región de colisión en el centro es donde se producen los choques de pro-

tones. Los imanes fuerzan a los rayos de protones a viajar en direcciones opuestas

y a chocar en el centro del detector. Los rayos se encuentran formados por haces

de protones. Cada haz contiene aproximadamente 100 billones de protones, pero

como las partículas son tan pequeñas la probabilidad de que colisionen es muy

pequeña, es del orden de 10 colisiones entre 100 billones de partículas.

Cuando dos protones de altas energías chocan, intercambian masa y energía a

través de partículas que usualmente no pueden ser creadas en el mundo que nos

rodea. La mayoría de estos procesos ya se encuentra bien entendida, solo alrededor

de 100 por cada billón de colisiones podrá producir física nueva interesante.

Hay que tener en cuenta que pasan alrededor de cuarenta millones de bunches

(paquetes de protones espacialmente cercanos dentro de los rayos) de protones

por segundo, es decir en promedio uno cada 25 nanosegundos.

Después de la colisión hay unos sensores segmentados de silicio (franjas y pixeles)

que se encargan de que las partículas cargadas sean rastreadas y que se pueda

medir su momento. También se encargan de mostrar los vértices y las posiciones

donde partículas inestables han decaído. Esta parte del detector tiene 205 m2 de

sensores de silicio que comprenden 9.3 millones de microfranjas y 66 millones de

pixeles [[8], [9]].

A continuación nos encontramos con cerca de 80.000 cristales de tungstenato

de plomo, que son centelladores (PbWO4) usados para medir con precisión las

energías de los electrones y los fotones; estos cristales conforman el calorímetro

electromagnético. También se encuentra el detector preshower hecho a base de

sensores de silicio que ayuda a la identicación de las partículas en las tapas del

barril que conforman el detector (endcaps).

3.0 10

Figura 3.3: Líneas de campo magnético desviadas por el yugo

Posteriormente nos encontramos con el calorímetro hadrónico que se encuentra

formado por capas densas se latón o acero intercaladas con centelleadores de plás-

tico o bras de cuarzo que permiten determinar la energía de los hadrones como

protones, neutrones, piones y kaones.

Como la mayoría de los detectores de física de partículas, el experimento CMS

tiene un gran imán de solenoide [8].

Esto permite que la relación carga masa de las partículas se pueda determinar

por la curva que siguen en presencia del campo magnético. Este imán tiene 13

metros de longitud y 6 metros de diámetro y se encuentra refrigerado por bobinas

superconductores de niobio-titanio, inicialmente debía producir un campo mag-

nético intenso de 4 Teslas, sin embargo se anunció que el campo producido será

de 3.8 Teslas para maximizar la longevidad del imán.

El campo magnético externo se logra por medio del soporte del solenoide (yugo)

que consiste en un armazón de hierro que desvía las líneas del campo magnético

que se generan dentro del solenoide como lo muestra la gura 3.3 generando un

campo opuesto al que está dentro del solenoide.

3.0 11

Este campo magnético externo es importante para la detección y la identica-

ción de los muones debido a la curva que estos siguen debido al campo, la cual va

a incidir en las señales obtenidas por las cámaras de muones para posteriormente

realizar la reconstrucción de la trayectoria del muon (Ver gura 3.2).

Para identicar los muones y medir su momento, el experimento CMS emplea

tres tipos de detectores: los tubos de deriva, las cámaras catódicas y las cámaras

de placas resistivas. Los tubos de deriva son empleados para realizar mediciones

precisas de la trayectoria de muones en la región central del barril, las cámaras

catódicas se emplean en las tapas del barril (endcaps). Finalmente las cámaras de

placas resistivas proveen una señal rápida cuando un muon pasa a través de ellas,

para generar la señal de trigger (disparo) de muones para las cámaras de tubos

de deriva y las cámaras catódicas, así como la señal de trigger del sistema global

del experimento CMS para la adquisición de datos. Estas son instaladas en ambas

regiones, en el barril y en las endcaps.

Capítulo 4

Detectores de ionización

Los detectores de ionización [10] son dispositivos diseñados para medir la ioni-

zación producida cuando una partícula atraviesa algún material. El objetivo del

detector es medir el número de electrones e iones positivos producidos cuando la

partícula atraviesa el material y así tener una idea de la energía depositada en el

detector; por esta razón se debe evitar que el par electrón-ion positivo interactúe

con los átomos del material recombinándose con estos, borrándose así la huella de

la ionización producida debido al paso de la partícula. Para lograrlo se emplea un

campo eléctrico a través del material que permite que los electrones y los iones

positivos se mantengan separados, y que viajen hacia sus respectivos electrodos

para así medir la ionización producida.

Un detector de ionización básico está compuesto de una cámara llena con un

material fácil de ionizar. Sin embargo este material debe ser químicamente estable

para evitar que los electrones producidos por la ionización sean nuevamente cap-

turados por las moléculas del material. La cámara también debe tener un ánodo

y un cátodo que se mantiene a una cierta diferencia de potencial (V) como se

observa en la gura 4.1. Además el material debe ser poco sensitivo a daños con

radiación, es decir que su respuesta a partículas incidentes no cambie mucho con

el tiempo, y adicionalmente debe poseer una baja energía de ionización para ma-

ximizar la tasa de ionización producida por energía depositada por una partícula

incidente.

4.0 13

Figura 4.1: Elementos básicos de un detector de ionización

Como se había mencionado antes, cuando una partícula atraviesa el detector

se ioniza el medio y se producen pares electrón-ion, estos comienzan a viajar a

través de las líneas del campo eléctrico del detector, los electrones hacia el ánodo

y los iones positivos hacia el cátodo. A medida que viajan inducen señales en los

electrodos que producen pequeñas corrientes que viajan a través de una resisten-

cia(R), esto a su vez produce una caída de voltaje que puede ser detectada por un

amplicador (A). El pulso que produce el amplicador puede ser analizado para

relacionarlo con la cantidad de ionización producida por la partícula incidente.

La cantidad de ionización producida depende de la densidad, de la estructura

atómica del medio ionizable y también de la carga y la energía de la partícula

incidente; mientras que la cantidad de ionización que es detectada depende más

de factores técnicos del detector, entre ellos la magnitud del campo eléctrico apli-

cado.

Cuando la diferencia de potencial entre los electrodos es pequeña, los electro-

nes y los iones positivos se recombinan rápidamente con el material, y solo unos

pocos electrones e iones alcanzan sus respectivos electrodos, esto nos da una señal

de salida que corresponde a la producción de pocos pares electrón-ion, mucho me-

nos que los que en realidad son producidos por el paso de la partícula. El rango

4.0 14

de voltaje donde esto ocurre se denomina región de recombinación. A medida

que la diferencia de potencial se incrementa mas allá del punto donde los pares

electrón-ion se recombinan obtenemos una señal que reeja la cantidad de ioniza-

ción producida, este rango de voltaje se denomina región de ionización.

Si continuamos incrementando el voltaje se le otorga suciente aceleración y

energía a los electrones para que puedan ionizar átomos adicionales del medio, la

señal de salida en esta región de voltaje es mayor pero proporcional a la ionización

producida inicialmente, esta región de voltaje se conoce como región proporcio-

nal. Si continuamos incrementando el voltaje obtenemos una avalancha de pares

electrón-ion esta región se conoce como región Geiger-Muller, la energía de la

ionización original incrementa lo sucientemente rápido produciendo muchas más

ionizaciones y electrones libres y fotones que a su vez producen ionización. Esto

produce muchos pares electrón-ion, y lo que obtenemos es una señal altamente

amplicada cuya magnitud es independiente de la cantidad de ionización produ-

cida originalmente. Finalmente si se continúa incrementado el voltaje se produce

una descarga continua del medio, donde el material pierde la sensibilidad a la

ionización incidente.

4.0 15

Figura 4.2: Señal de respuesta en función del voltaje aplicado [11]

Capítulo 5

Cámaras de Placas resistivas

Las Cámaras de Placas resistivas (RPC por sus siglas en inglés) son detecto-

res gaseosos que pueden registrar el paso de partículas cargadas con muy buen

tiempo de resolución (desde 1 ns hasta 50 ps) y también buena resolución espacial

(hasta 30µm). Son apropiadas para experimentos que necesitan detección espacio-

temporal de partículas de forma rápida.

Una RPC consiste en dos placas paralelas hechas con un laminado plástico

de alta presión; en este caso de una resina fenólica: baquelita. Las placas tienen

una resistividad de 1010 − 1011Ωcm, separadas por un gas que ocupa unos pocos

milímetros. Las capas externas de la baquelita son cubiertas con pintura de grato

para formar los electrodos de la cámara, uno desempeñará la función de tierra, y

el otro estará a un potencial determinado para lograr la medición de la ionización

producida en la cámara (Ver [14]). La señal de salida se obtiene en unas franjas de

aluminio que se encuentran separadas del grato por un aislante (mylar, película

PET).

La región del barril del experimento CMS viene equipada con 480 RPC de

cámara doble que son operadas en modo avalancha empleando una mezcla de gas

Freón. Se han realizado muchos esfuerzos para construir un detector capaz de sa-

tisfacer los requerimientos necesarios para operar bajo un alto ujo de partículas,

como el que se presentará durante la operación normal del CMS. Por este motivo

se requiere que las cámaras RPC tengan una gran eciencia para detectar muones,

5.1 17

que sean capaces de soportar un gran ujo de partículas, y como lo había mencio-

nado antes, que tengan una buena resolución temporal y espacial. Adicionalmente

se requiere que tengan baja sensibilidad al paso de neutrones y rayos gamma.

5.1. Modos de operación

Se puede operar la RPC en distintos modos, en el modo streamer la RPC

opera con un campo eléctrico intenso que produce descargas localizadas del gas

en la región cercana a la que pasó la partícula ionizante, sin embargo este modo

de operación permite pocos conteos por unidad de área (∼ 100Hz/cm2).

Otro modo de operación es el modo de avalancha, donde el campo eléctrico entre

las placas se reduce, y se amplica la señal de salida, esta reducción en el voltaje

disminuye la carga generada en la ionización y permite incrementar la capacidad

de conteos de la cámara. Los electrones producidos por la ionización debido a la

presencia de partículas cargadas en el gas son multiplicados en el modo de ava-

lancha por un campo eléctrico uniforme de alrededor de 4.5 kV/mm.

Los valores típicos de carga inducida cuando la RPC se encuentra en modo de

avalancha son alrededor de unos pocos pC. Este valor se multiplica por un factor

mayor de 50 cuando se encuentra en el modo streamer. El modo streamer es

usado principalmente en rayos cósmicos como en experimentos de altas energías,

mientras que el modo avalancha es usado en aplicaciones que requieren la detec-

ción de altos ujos de partículas [12].

Una vez que se obtiene la señal, ésta es leída empleando un acoplamiento ca-

pacitivo por medio de franjas de aluminio en la parte externa de los electrodos

(Ver gura 5.1).

Las RPC tienen una estructura mecánica simple, no utiliza cables, y por lo

tanto son fáciles de fabricar. Se pueden usar dos RPC para formar una estructura

de cámara doble con franjas comunes de aluminio en el medio (ver gura 5.2).

Una cámara RPC tiene la capacidad de diferenciar ionizaciones en tiempos

menores de 25 ns entre dos cruces sucesivos de haces de partículas.

5.1 18

Figura 5.1: Sección transversal de una RPC formada por dos placas separadaspor un gas (2 mm de ancho). Se aplica un campo de alrededor de 4.5 kV/mm enlos electrodos de la cámara [12].

Figura 5.2: Dos cámaras RPC unidas para formar una cámara doble con lasfranjas de aluminio [12].

5.2 19

Figura 5.3: Suedorapidez, parámetro η relacionado con el ángulo θ

Un detector de muones basado en RPC puede identicar sin ambigüedad los

cruces de haces de los cuales se originó la huella de un muón, incluso cuando

el sistema tiene una alta incidencia de muones. Todas estas funciones se pueden

cumplir en un ambiente donde la tasa de impactos alcance el valor de 103Hz/cm2.

5.2. Parámetro η: La seudorapidez

Uno de los parámetros empleados para la ubicación espacial en el experimento

CMS es el parámetro η, o seudorapidez, este parámetro está relacionado con la

ubicación angular en la que nos encontramos. η está denido como:

η = − ln(tanθ

2) (5.1)

Para detectar y medir el momento de los muones se emplean tres tecnologías

diferentes: Los tubos de deriva (Drift Tubes) que se encuentran en la región del

barril 0 ≤ η ≤ 1,3, las cámaras catódicas (cathode strip chambers) que se encuen-

tran en las tapas (endcaps) y las RPC que se encuentran en ambas regiones. (Ver

gura 5.4)

5.3 20

Figura 5.4: Sistema de muones en el plano (R,z)

El sistema de RPCs en el barril esta hecho de 480 cámaras dobles (ver gura

5.2) distribuidas en cuatro capas (ver gura 5.5) distribuidas en cinco anillos que

están acoplados con los tubos de deriva (ver gura 5.6).

5.3. Principio de Operación

La resistividad de los electrodos determina principalmente la tasa de conteos

de la RPC, mientras que el espacio con el gas determina el rendimiento en tiempo

de la cámara. Otros parámetros importantes para alcanzar el mejor rendimiento

son la densidad del gas en la cámara y el grosor de los electrodos.

Cuando una partícula cargada pasa por una RPC ioniza el gas que se encuen-

tra entre las placas produciendo un cúmulo de electrones (n0) lo que a su vez

produce una avalancha de electrones debido al campo eléctrico presente entre las

placas (Ver gura 5.7).

Esta avalancha genera una carga eléctrica Qe en el gas de espesor d. El viaje de

5.3 21

Figura 5.5: Conguración de las RPC en el barril

Figura 5.6: Cámaras RPC distribuidas en cinco anillos y acopladas con los tubosde deriva.

5.3 22

Figura 5.7: Formación de la carga en la RPC. [13]

esta carga generada hacia el ánodo induce rápidamente en uno de los electrodos

la carga qe, que representa la señal que recibe la RPC de la ionización. La fuente

tiene que mover la carga qs en el circuito fuera del gas para compensar la carga

colectada en los electrodos.

Si α es el número de encuentros ionizantes por unidad de longitud sufridos

por un electrón y el coeciente de acoplamiento β es el número de encuentros

de acople por unidad de longitud, entonces la ionización efectiva se puede denir

como η = α− β

Una RPC se encuentra en el modo de avalancha cuando se cumple la condición

ηd < 20

En este caso como muestran en [14], el promedio de carga inducida en uno de

los electrodos (qe) se obtiene de la siguiente forma:

〈qe〉 =k

ηd〈Qe(d)〉 = qeln0e

ηd kλ

ηd(η + λ)(5.2)

Donde:

k = εrd/sεrd/s+2

es una constante que depende de los parámetros del material

qel es la carga del electrón

5.3 23

n0 es el tamaño promedio del cumulo de carga de donde se originó la ava-

lancha

λ es la densidad del cúmulo en el gas (el número de cúmulos primarios por

unidad de longitud producidos por una partícula ionizante)

εr es la constante dieléctrica relativa del electrodo

d es el espesor del gas (2 mm en nuestro caso)

s es el espesor del electrodo

Para un valor dado de ηd los factores k y λ deben de ser lo más grande

posible para maximizar la señal que se obtiene en las franjas de aluminio. Una

mejor aproximación de la carga promedio inducida se puede obtener empleando

simulaciones de Monte Carlo, donde las uctuaciones de la avalancha producida

también se pueden tener en cuenta.

Capítulo 6

Simulación de una placa de aluminio

El objetivo de la simulación es tener una idea de lo que sucede con las cámaras

RPC en el experimento CMS. Debido a que las cámaras se encuentran dentro de

cajas de aluminio, entonces hacemos inicialmente un estudio del efecto del paso

de los muones a través del aluminio.

Para la energía de los muones utilizamos 1 GeV debido a que es la energía pro-

medio que se obtiene para los muones como resultado de una simulación realizada

en [1].

El objetivo de esta simulación es observar la cantidad de gammas producidos

debido a la incidencia de muones, realizar un histograma de las energías obte-

nidas y además hacer un estudio de tamaño de cumulo producido (cluster size)

mediante una gráca de las posiciones obtenidas de los gammas.

6.1. Simulación implementada

Inicialmente se creó la clase DetectorConstruction, a la que se le ingresó una

placa de aluminio de 30 cms de ancho por 30 cms de largo y 3 mm de espesor (Ver

gura 6.1). Esta placa se rodeó de aire para simular las condiciones reales en las

que se encuentra en el experimento CMS. Adicionalmente, se creó una cámara de

aire a 2 milímetros de la placa de aluminio de 4 mm de espesor y también 30 cms

6.1 25

Figura 6.1: Placa de aluminio (rojo) implementada para la simulación rodeada deaire y con una cámara de aire adicional (blanco) para tener en cuenta los gammasque ingresan a ella.

de largo y de ancho (Ver gura 6.1). Esta cámara se creó para tener en cuenta

todos los gammas que ingresarán a ella.

Las partículas que se tuvieron en cuenta para esta simulación fueron foto-

nes, electrones, positrones, muones y antimuones. Los procesos que se tuvieron en

cuenta fueron efecto compton, efecto fotoeléctrico, conversión gamma, dispersión

múltiple, ionización, bremsstrahlung, creación de pares, y aniquilación de positro-

nes. Para implementar estas partículas y procesos se creó la clase PhysicsList.

Adicionalmente se creó la clase PrimaryGeneratorAction en donde hacemos in-

cidir partículas (en este caso muones) donde se inicia la placa de aluminio (ver

gura 6.2), los muones se hacen incidir desde el centro de la placa, perpendiculares

a la placa con una energía de 1 GeV. En la simulación se hacen incidir un millón

6.2 26

Figura 6.2: Incidencia de muones en el interfaz aluminio-aire

de muones.

Tambien se creó la clase "HistoManager"que se encarga de crear los histogra-

mas y la gráca de posición de las partículas obtenidas (Scatter Plot), esta clase

emplea el interfaz Aida que es un software adicional a Geant4 para realizar análi-

sis de datos e histogramas. Todas las clases creadas se encuentran en el apéndice

Clases implementadas para la simulación de la placa de aluminio.

6.2. Resultados obtenidos

Con las energías de los gammas, que alcanzan a llegar a la cámara de aire que

está a 2 mm de la placa de aluminio debido a la incidencia de un millón de muones

6.2 27

Figura 6.3: Histograma de las energías de los gammas que se obtienen por laincidencia de un millón muones positivos a 1 GeV.

positivos con 1 GeV de energía, se construye un histograma (Ver gura 6.3 y 6.4).

También se construye una gráca con las posiciones X y Y de los gammas que

alcanzan a llegar a la cámara aire (Ver gura 6.5 y 6.6), la posición en Z siempre

es 2 mm, ya que la cámara de aire se creó a 2 mm de la placa de aluminio.

Se realiza el mismo procedimiento de los muones positivos para muones nega-

tivos, con lo que se obtiene los histogramas de energías de los gammas (Ver gura

6.7 y 6.8 ) y una gráca de posiciones (Ver gura 6.9 y 6.10 )

Con los resultados obtenidos en la gura 6.3 y la gura 6.7 podemos concluir

que se producen alrededor de 0.0081 gammas por la incidencia de 1 muón (prome-

diamos los valores para muones negativos y positivos) a la placa de aluminio con

una energía media de 0.237 MeV. También podemos ver al observar las guras

6.6 y 6.10 que el tamaño del cumulo de gammas (cluster size) producido por el

6.2 28

Figura 6.4: Histograma de las energías de los gammas que se obtienen por laincidencia de un millón de muones positivos a 1 GeV con eje logarítmico.

6.2 29

Figura 6.5: Posiciones X y Y de los gammas producidos por la incidencia de unmillón muones positivos a 1 GeV.

6.2 30

Figura 6.6: Posiciones X y Y de los gammas producidos por la indicidencia de unmillón de muones a 1 GeV positivos con los ejes ampliados.

6.2 31

Figura 6.7: Histograma de las energías de los gammas que se obtienen por laincidencia de un millón de muones negativos a 1 GeV.

6.2 32

Figura 6.8: Histograma de las energías de los gammas que se obtienen por laincidencia de un millón de muones negativos a 1 GeV con eje logarítmico.

6.2 33

Figura 6.9: Posiciones X y Y de los gammas producidos por la incidencia de unmillón de muones negativos a 1 GeV.

6.2 34

Figura 6.10: Posiciones X y Y de los gammas producidos por la incidencia de unmillón de muones negativos a 1 GeV con los ejes ampliados.

6.2 35

paso de muones sobre el aluminio es aproximadamente un círculo con radio de 15

milímetros.

Capítulo 7

Simulación de una RPC

El objetivo de esta simulación es observar la cantidad de electrones producidos

en la cámara de gas de una RPC debido a la incidencia de muones sobre la cámara,

realizar un histograma de las energías obtenidas y además realizar un estudio de

tamaño de cúmulo producido (cluster size) al realizar una gráca de las posiciones

obtenidas de los electrones.

Inicialmente se creó la clase DetectorConstruction, a la que se le ingresó la

geometría de una cámara RPC de la siguiente forma (Ver gura 7.1 y gura 7.2):

Dos capas de polietileno de 30 cms de ancho por 30 cms de largo y 0.2 mm

de espesor.

Dos capas de grato de 30 cms de ancho por 30 cms de largo y 0.2 mm de

espesor.

Dos capas de Baquelita de 30 cms de ancho por 30 cms de largo y 2 mm de

espesor.

Una cámara de gas (C2H2F4) de 30 cms de ancho por 30 cms de largo y 2

mm de espesor.

Una capa de aluminio de 30 cms de ancho por 30 cms de largo y 0.04 mm

de espesor.

La RPC se rodeó de aire para simular las condiciones reales en las que se encuentra

en el experimento CMS.

7.0 37

Figura 7.1: Grosor de los materiales de la RPC.

Figura 7.2: Cámara implementada con polietileno (amarillo), grato (gris oscuro),baquelita (gris claro), gas (negro) y aluminio (rojo) para simular la RPC.

7.1 38

Figura 7.3: Incidencia de muones a 2 cm de la RPC

Las partículas que se tuvieron en cuenta para esta simulación fueron foto-

nes, electrones, positrones, muones y antimuones. Los procesos que se tuvieron en

cuenta fueron efecto compton, efecto fotoeléctrico, conversión gamma, dispersión

múltiple, ionización, bremsstrahlung, creación de pares, y aniquilación de positro-

nes. Para implementar estas partículas y procesos se creó la clase PhysicsList.

Adicionalmente se creó la clase PrimaryGeneratorAction en donde hacemos inci-

dir partículas (en este caso muones) a 2 cm de la RPC (ver gura 7.3), los muones

se hacen incidir desde el centro, perpendiculares a la RPC con una energía de 1

GeV. Se hacen incidir en total un millón de muones.

De igual forma se creó un campo eléctrico uniforme de 4.5 kV/mm en la cá-

mara, este campo es necesario para que la RPC funcione en modo de avalancha.

También se creó la clase HistoManager que se encarga de crear los histogramas y

la gráca de posición de las partículas obtenidas (Scatter Plot), esta clase emplea

el interfaz Aida. Todas las clases creadas se encuentran en el apéndice Clases

implementadas para la simulación de la RPC.

7.1 39

Figura 7.4: Histograma de las energías de los electrones que se obtienen en el gasde la RPC debido a la incidencia de un millón de muones positivos de 1 GeV y enpresencia de un campo eléctrico de 4.5 kV/mm.

7.1. Resultados obtenidos

7.1.1. Incidencia de muones positivos

Con las energías de los electrones producidos debido al paso de muones posi-

tivos por el gas de la RPC se construye unos histogramas (Ver gura 7.4 y 7.5).

También se construye una gráca con las posiciones X y Y de los electrones produ-

cidos en el gas (Ver gura 7.6), y adicionalmente se construyen grácas teniendo

en cuenta la distribución de los ángulos de los electrones obtenidos (Ver gura 7.7

y 7.9).

7.1 40

Figura 7.5: Histograma de las energías de los electrones que se obtienen en el gasde la RPC debido a la incidencia de un millón de muones positivos de 1 GeV y enpresencia de un campo eléctrico de 4.5 kV/mm con eje logarítmico.

7.1 41

Figura 7.6: Posiciones X y Y de los electrones producidos en el gas de la RPCdebido a la incidencia de un millón de muones positivos de 1 GeV y en presenciade un campo eléctrico de 4.5 kV/mm.

7.1 42

Figura 7.7: Distribución angular (cos θ) de los electrones producidos en el gas dela RPC debido a la incidencia de un millón de muones positivos de 1 GeV y enpresencia de un campo eléctrico de 4.5 kV/mm.

7.2 43

Figura 7.8: Angulo polar θ y azimutal φ.

Debe tenerse en cuenta que theta es el ángulo polar, lo que signica que θ = 180

grados (cos θ = −1) signica seguir en línea recta hacia adelante. Y θ = 180 grados

(cos θ = 1) signica rebotar, que la partícula se está devolviendo. También hay

que tener en cuenta que φ es el ángulo azimutal (Ver gura 7.8).

7.1.2. Incidencia de muones negativos

Se realiza el mismo procedimiento de los muones positivos para muones nega-

tivos y se obtienen los resultados de las guras 7.10,7.11,7.12,7.13,7.14.

7.1.3. Incidencia de gammas

Se realiza el mismo procedimiento de los muones positivos para gammas de

0.237 MeV que fue la energía media que se obtuvo de la incidencia de muones

positivos y negativos sobre aluminio en la sección Simulación de una placa de

aluminio y obtenemos los resultados de las guras 7.15,7.16,7.17,7.18,7.19.

7.2. Análisis de resultados

Las distribuciones angulares de electrones que resultan de muones positivos y

muones negativos son similares (ver guras 7.7, 7.9, 7.13, 7.14) lo que concuerda

con los resultados experimentales, en principio no deben de ser diferentes. Tam-

bien se puede observar que la mitad de los electrones esta para cos θ < −0,35 en

7.2 44

Figura 7.9: Distribución angular φ de los electrones producidos en el gas de laRPC debido a la incidencia de un millón de muones positivos de 1 GeV y enpresencia de un campo eléctrico de 4.5 kV/mm.

7.2 45

Figura 7.10: Histograma de las energías de los electrones que se obtienen en elgas de la RPC debido a la incidencia de un millón de muones negativos de 1 GeVy en presencia de un campo eléctrico de 4.5 kV/mm.

7.2 46

Figura 7.11: Histograma de las energías de los electrones que se obtienen en elgas de la RPC debido a la incidencia de un millón de muones negativos de 1 GeVy en presencia de un campo eléctrico de 4.5 kV/mm con eje logarítmico.

7.2 47

Figura 7.12: Posiciones X y Y de los electrones producidos en el gas de la RPCdebido a la incidencia de un millón de muones negativos de 1 GeV y en presenciade un campo eléctrico de 4.5 kV/mm.

7.2 48

Figura 7.13: Distribución angular (cos θ) de los electrones producidos en el gasde la RPC debido a la incidencia de un millón de muones negativos de 1 GeV yen presencia de un campo eléctrico de 4.5 kV/mm.

7.2 49

Figura 7.14: Distribución angular φ de los electrones producidos en el gas de laRPC debido a la incidencia de un millón de muones negativos de 1 GeV y enpresencia de un campo eléctrico de 4.5 kV/mm.

7.2 50

Figura 7.15: Histograma de las energías de los electrones que se obtienen en elgas de la RPC debido a la incidencia de un millón de gammas de 0.237 MeV y enpresencia de un campo eléctrico de 4.5 kV/mm.

7.2 51

Figura 7.16: Histograma de las energías de los electrones que se obtienen en elgas de la RPC debido a la incidencia de un millón gammas de 0.237 MeV y enpresencia de un campo eléctrico de 4.5 kV/mm con eje logarítmico.

7.2 52

Figura 7.17: Posiciones X y Y de los electrones producidos en el gas de la RPCdebido a la incidencia de un millón gammas de 0.237 MeV y en presencia de uncampo eléctrico de 4.5 kV/mm.

7.2 53

Figura 7.18: Distribución angular (cos θ) de los electrones producidos en el gasde la RPC debido a la incidencia de un millón de gammas de 0.237 MeV y enpresencia de un campo eléctrico de 4.5 kV/mm.

7.2 54

Figura 7.19: Distribución angular φ de los electrones producidos en el gas de laRPC debido a la incidencia de un millón gammas de 0.237 MeV y en presencia deun campo eléctrico de 4.5 kV/mm.

7.2 55

el caso de gammas, cos θ < −0,38 para muones positivos y cos θ < −0,38 para

muones negativos. Lo que signica que la mitad de los electrones sigue hacia ade-

lante, es decir la mitad de los electrones obtenidos tienen un ángulo θ mayor a 112

grados. La distribución angular azimutal es similar para todos los casos y esto es

lo que se esperá ya que no hay razón para que haya un angulo φ privilegiado.

Las gracas de distribución de posición (scatterplots) para los electrones que

resultan de muones positivos y muones negativos son iguales lo que concuerda con

los valores experimentales (no varían mucho), y se halló que la mayor parte del

cúmulo de electrones producido (cluster size) se encuentra para un radio aproxi-

mado de 25 mm alrededor del punto de incidencia. Si comparamos con la gráca

de distribución de posición para los eléctrones que resultan de la incidencia de

gammas encontramos que la mayor parte del cúmulo de electrones se encuentra

para un radio aproximado de 60 mm, lo cual es más de dos veces mayor que en el

caso de electrones, que resultan de muones incidiendo en la cámara. Esto concuer-

da bastante bien con lo esperado debido a que los muones son partículas mínimo

ionizantes, luego la huella producida es pequeña, es decir el radio del cumulo debe

de ser pequeño alrededor del punto de incidencia. En contraste con los gammas, la

huella es mucho más grande; de donde se puede concluir que con solo ver el patrón

resultante, la huella dejada en el detector al paso de las partículas, se puede saber,

a simple vista, qué tipo de partícula pasó, si muón o gamma. Luego para el paso

de gammas deben de responder simultáneamente varios strips vecinos que son las

franjas de aluminio que reciben la señal de la cámara. Para muones no, tan solo

uno o dos strips seguidos.

Capítulo 8

Conclusiones

Gracias al desarrollo de este trabajo se han obtenido ideas acerca de como es

el comportamiento de las cámaras de muones en el experimento. Por otro lado, el

autor ha alcanzado conocimiento valioso de las herramientas de simulación rela-

cionadas con la física de altas energías en particular el uso del software Geant4.

Dentro de los logros alcanzados se encuentra el hecho de implementar el in-

terfaz Aida para obtener histogramas y scatterplots desde geant4. Este interfaz

permite que simultáneamente con la corrida de la simulación se obtengan los his-

togramas, lo que optimiza el tiempo de computo empleado para la simulación

permitiendo realizar una gran cantidad de eventos (106 eventos).

Con los resultados de la simulación se puede concluir que la cámara RPC no

puede distinguir entre la señal producida por un muón positivo y uno negativo,

esta distinción se logra con el campo magnético externo al solenoide del CMS, el

cual desvía la trayectoria de manera diferente dependiendo de si la partícula es

un muón positivo o un muon negativo.

Para la incidencia de un millón de muones de 1 GeV sobre una placa de 3

mm de espesor de aluminio se encontró que el número de gammas producido era

alrededor de 8200 con una energía media de 0.237 MeV.

8.0 57

Se encontró además que el tamaño del cumulo de electrones debido al paso de

muones de 1 GeV en el gas de la RPC era alrededor de 25 mm, mientras que era

de cerca de 60 mm para gammas de 0.237 MeV. Luego para el paso de gammas

deben de responder simultáneamente varios strips vecinos que son las franjas de

aluminio que reciben la señal de la cámara. Para muones no, tan solo uno o dos

strips seguidos.

Se recomienda para próximos trabajos con simulación a la hora de hacer incidir

partículas no solo tener en cuenta una energía media para la partícula incidente si

no una distribución de energías debido a que el software permite la incidencia de

partículas con varias distribuciones. También se recomienda realizar la simulación

con partículas incidentes desde varias direcciones y no desde un solo punto, con

esto logramos acercarnos más a la realidad.

Apéndice A

¾Cómo instalar Geant4?

A.1. Introducción

Primero debemos de tener en cuenta qué sistema operativo vamos a emplear

para la instalación, en mi caso recomiendo Mandriva 2007 ya que lo emplee sin

ningún problema. En el siguiente link se encuentra un instructivo completo de

cómo instalar geant4 :

http://geant4.slac.stanford.edu/tutorial/installation/Geant4.9.0

/Linux/Geant4_9_0_Linux_Installation.htm

De todas formas decidí escribir este instructivo para describir con mayor de-

talle algunos pasos que pueden generar problemas.

Antes de iniciar la instalación debes de tener en cuenta qué tipo de compila-

dor empleas para la instalación, un compilador es un programa informático que

traduce un programa escrito en un lenguaje de programación a otro lenguaje de

programación, generando un programa equivalente que el computador será capaz

de interpretar [14], en este caso el compilador se encarga de que el código con el

que fue escrito geant4 lo pueda entender el computador que estamos usando.

A.2 59

Es muy importante que tengas las siguientes versiones de compilador: gcc 3.2.3,

gcc 3.4.5 o incluso gcc 4.1.1. No podrías tener éxito si usas una versión diferente.

Para saber qué versión tienes, solo tienes que abrir una terminal (o shell).Y una

vez abierta la terminal escribes:

gcc -v

Y así sabrás que versión de compilador tienes, si no tienes una versión que con-

cuerde con las que describí al inicio te recomiendo que emplees otra distribución

de Linux (como dije anteriormente recomiendo Mandriva 2007).

A.2. Bajando los paquetes necesarios

Para instalar geant4 necesitarás bajarte de internet los siguientes archivos:

-Paquetes de instalación de Geant4, en este caso vamos a instalar la versión 4.9.0

que fue la que empleé. Estos paquetes los encontrarás en la siguiente dirección:

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

Es un archivo de cerca de 16 Mb

-Paquetes de instalación de CLHEP. Estas son una serie de librerías desarro-

lladas para física de altas energías, las puedes bajar de la siguiente dirección:

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

2.0.3.1.tgz

A.3 60

Es un archivo de cerca de 5 Mb

Paquetes de instalación de GAEMLOW. Estos son unos archivos de datos que

contienen información para procesos electromagnéticos de baja energía. Se pueden

bajar de la siguiente dirección:

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

Es un archivo de cerca de 7.6 Mb

A.3. Creando las carpetas de instalación

Hay que tener en cuenta que la creación de las carpetas también se puede

hacer usando el entorno gráco del sistema operativo, con lo cual resulta mucho

más sencillo hacerlo, de todas formas describo aquí como realizarlo a través de la

terminal.

Primero tenemos que denir una carpeta donde vamos a poner todo el sof-

tware, digamos que la llamaremos Simulacion pero hay libertad para escoger el

nombre que se desee. Esta carpeta la podemos crear en cualquier parte. Te reco-

miendo la siguiente ubicación:

/home/nombre de usuario/

Como mi nombre de usuario es andres (este nombre de usuario lo denes cuando

estas instalando linux), entonces la ubicación sería la siguiente:

/home/andres/

A.4 61

Para llegar hasta esa ubicación escribes en la terminal lo siguiente: cd /home/andres/

Luego creamos la carpeta Simulacion, que es donde irá todo lo referente a Geant4,

para lo cual escribes lo siguiente en la terminal:

mkdir Simulacion

para comprobar que te quedó bien solo tienes que escribir

ls

y deberás de observar que obtienes como respuesta varios archivos, entro ellos

el siguiente:

Simulacion/

Luego vamos a crear dos directorios (carpetas) dentro de esta carpeta, una

para geant4 y otra para CLHEP, para lo cual escribirás

cd Simulacion/

que te permite entrar en el directorio y luego

mkdir geant4

mkdir CLHEP

lo cual creará las dos carpetas geant4 y CLHEP.

Una vez estén creadas las carpetas moverás el archivo que contiene los paquetes

de instalación de geant4 (geant4.9.0.tar.gz) a la carpeta geant4, y los paquetes

del CLHEP (clhep-2.0.3.1.tgz) a la carpeta CLHEP.

A.4 62

A.4. Instalando las librerías CLHEP

Ahora procederemos a instalar las librerías de CLHEP, primero asegúrate que

en la terminal te encuentras en el directorio donde están las carpetas creadas en el

paso anterior (geant4 y CLHEP); en este caso que te encuentras en la carpeta

que yo llamé Simulacion.

Primero entra a la carpeta del CLHEP escribiendo

cd CLHEP/

Luego escribirás lo siguiente:

tar -zxvf clhep-2.0.3.1.tgz

Este comando ejecuta la descompresión del archivo clhep-2.0.3.1.tgz y los archivos

descomprimidos los adiciona a la carpeta CLHEP.

El proceso de descompresión debe iniciar con lo siguiente en la terminal:

2.0.3.1/ 2.0.3.1/CLHEP/ 2.0.3.1/CLHEP/CVS/ 2.0.3.1/CLHEP/CVS/Root

2.0.3.1/CLHEP/CVS/Repository

Y debe finalizar con: 2.0.3.1/CLHEP/install-sh

2.0.3.1/CLHEP/config.guess 2.0.3.1/CLHEP/config.sub

2.0.3.1/CLHEP/Makefile.in 2.0.3.1/CLHEP/configure

Para comprobar que realizaste bien el paso anterior escribe lo siguiente:

ls

Deberás obtener como resultado varias carpetas entre ellas una llamada 2.0.3.1

Ahora tenemos que entrar en la carpeta CLHEP que se encuentra en 2.0.3.1.

Para lo cual deberás escribir:

cd 2.0.3.1/CLHEP

A.4 63

Para el siguiente comando necesitarás usar el camino completo donde se en-

cuentra la carpeta CLHEP que se creó en la sección Creando las carpetas de

instalación.

Para nuestro ejemplo ese camino sería:

/home/andres/Simulacion/CLHEP

Luego el comando quedaría así:

/configure --prefix /home/andres/Simulacion/CLHEP

Si tienes la carpeta en otra ubicación asegúrate de usar el camino completo.

Por ejemplo si tienes otro nombre de usuario (ej:juan) y otro nombre para la

carpeta Simulación (ej:tesis), el comando quedaria así:

./configure --prefix /home/juan/tesis/CLHEP

Al ejecutar este comando deberás obtener una respuesta similar a lo siguiente:

checking build system type... i686-pc-linux-gnu checking host system

type... i686-pc-linux-gnu checking target system type...

i686-pc-linux-gnu checking for a BSD-compatible install...

/usr/bin/install -c checking whether build environment is sane...

yes

Y el proceso nalizará con algo similar a lo siguiente:

config.status: creating test/exctest4.sh config.status: creating

test/exctestNothrow.sh config.status: creating test/excDblThrow.sh

A.4 64

config.status: creating Exceptions/defs.h config.status: executing

depfiles commands

\newline\newline

Una vez realizado esto escribe el siguiente commando

make

Debes obtener una respuesta similar a la siguiente:

Making all in Units

make[1]: Entering directory

`/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/2.0.3.1

/CLHEP/Units'

Making all in Units make[2]: Entering directory


/CLHEP/Units/Units'

make all-am\newline\newline Y finalizar con algo similar a lo

siguiente: \newline\newline make[1]: Entering directory

`/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/2.0.3.1/CLHEP'

./build-clheplib Units Vector Evaluator GenericFunctions Geometry

Random Matrix RandomObjects RefCount Cast Exceptions rm -f

libCLHEP-2.0.3.1.a liblist=`./getObjectList -static Units Vector

Evaluator GenericFunctions Geometry Random Matrix RandomObjects

RefCount Cast Exceptions`; \ ar cru libCLHEP-2.0.3.1.a $liblist;

ranlib libCLHEP-2.0.3.1.a rm -f libCLHEP-2.0.3.1.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.3.1.so -shared -Wl,-soname,libCLHEP-2.0.3.1.so $liblist

-o libCLHEP-2.0.3.1.so make[1]: Leaving directory

`/afs/slac.stanford.edu//home/andres/Simulacion/CLHEP/2.0.3.1/CLHEP'

A.4 65

Una vez realizado esto debemos escribir

make install

Debes de obtener una respuesta similar a la siguiente:

Making install in Units make[1]: Entering directory


/CLHEP/Units'

Making install in Units make[2]: Entering directory


/CLHEP/Units/Units'

Y nalizar con algo similar a lo siguiente:

test -z "/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/lib" ||

mkdir -p --

"/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/lib"

/usr/bin/install -c -m 644 'libCLHEP-2.0.3.1.a' '/afs/slac.stanford.edu

/home/andres/Simulacion/CLHEP/lib/libCLHEP-2.0.3.1.a'

ranlib '/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/lib

/libCLHEP-2.0.3.1.a'

/usr/bin/install -c 'libCLHEP-2.0.3.1.so' '/afs/slac.stanford.edu

/home/andres/Simulacion/CLHEP/lib/libCLHEP-2.0.3.1.so'

make[2]: Nothing to be done for `install-data-am'. make[2]: Leaving

directory


make[1]: Leaving directory


Si todo ha salido bien en la carpeta CLHEP (en nuestro caso

/home/andres/Simulacion/CLHEP) deberemos encontrar carpetas nuevas como

include y lib.

A.5 66

Con esto nalizamos la instalación de las librerías CLHEP.

A.5. Descomprimiendo los archivos de Geant4

Necesitarás entrar la carpeta geant4 creada en la sección Creando las car-

petas de instalación. Para nuestro caso esta carpeta se encuentra en la siguiente

dirección:

/home/andres/Simulacion/geant4

Para entrar a la carpeta escribimios:

cd /home/andres/Simulacion/geant4

En esta carpeta deberá de encontrarse el archivo geant4.9.0.tar.gz si no lo tienes

deberás regresar a la sección Bajando los paquetes necesarios.

Si ya tienes el archivo geant4.9.0.tar.gz en la carpeta entonces ingresa lo si-

guiente a la terminal:

tar -zxvf geant4.9.0.tar.gz

Con esto se iniciará el proceso de descompresión, que debería de iniciar con lo

siguiente:

geant4.9.0/ geant4.9.0/ReleaseNotes/

geant4.9.0/ReleaseNotes/Patch4.4.0-1.txt



Y finalizar con algo similar a lo siguiente:

geant4.9.0/source/visualization/modeling/src/

G4TrajectoryOriginVolumeFilter.cc

A.6 67


G4TrajectoryParticleFilter.cc


G4VModel.cc


G4VTrajectoryModel.cc


G4VisTrajContext.cc

A.6. Descomprimiendo los archivos para procesos

electromagnéticos de baja energía

Dependiendo de la física que necesites para tu simulación, necesitaras instalar

paquetes adicionales a Geant4, estos paquetes los puedes encontrar en la siguiente

dirección: http://geant4.web.cern.ch/geant4/support/download.shtml

En nuestro caso vamos a usar el paquete G4EMLOW.4.3.tar.gz que obtuvimos

en la sección Bajando los paquetes necesarios. Creamos una carpeta nueva para

guardar este paquete que se llamará data; esta carpeta quedará ubicada en la

carpeta geant4.9.0 que se encuentra dentro de la carpeta geant4. Para crear la

carpeta ingresamos a geant4.9.0 escribiendo:

cd geant4.9.0/

y luego creamos la carpeta data ingresando:

mkdir data

En la carpeta data guardamos el archivo G4EMLOW.4.3.tar.gz que se ob-

tuvo en la sección Bajando los paquetes necesarios. Este archivo contiene la

información para procesos electromagnéticos de baja energía. Una vez tengamos

el archivo en la carpeta data los descomprimimos. Para realizarlo primero ingre-

samos a la carpeta:

cd data/

A.7 68

Y luego descomprimimos el archivo ingresando:

tar -zxvf G4EMLOW.4.3.tar.gz

El proceso de descompresión debe de iniciar con algo similar a lo siguiente:

G4EMLOW4.3/ G4EMLOW4.3/README G4EMLOW4.3/auger/

G4EMLOW4.3/auger/au-tr-pr-10.dat G4EMLOW4.3/auger/au-tr-pr-11.dat

Y debe de nalizar con:

G4EMLOW4.3/tripdata/pp-trip-cs-9.dat

G4EMLOW4.3/photoelectric_angular/

G4EMLOW4.3/photoelectric_angular/ftab0.dat

G4EMLOW4.3/photoelectric_angular/ftab1.dat G4EMLOW4.3/History

A.7. Instalando Geant4

En esta parte debemos ser muy cuidadosos, ya que si nos equivocamos obten-

dremos una instalación errónea, en este caso nos correspondería iniciar el proceso

de instalación de cero.

En la terminal entramos a la carpeta donde tenemos geant4 para hacerlo es-

cribimos, para nuestro ejemplo sería:

cd /home/andres/Simulacion/geant4/geant4.9.0/

Luego escribimos el siguiente comando:

./Congure -build

Al ingresar este comando, en la terminal le comenzarán a salir varias pregun-

tas a las que les debe de dar la respuesta por defecto presionando enter. Pero a las

A.7 69

siguientes preguntas no debes de darle la respuesta por defecto, debes de cambiar

la respuesta.

Cuando se le pregunte:

Could not find CLHEP installed on this system! Please, specify where

CLHEP is installed:

Entonces debes de ingresar la ubicación donde tienes las librerias CLHEP para

nuestro ejemplo sería ingresar:

/home/andres/Simulacion/CLHEP

Tomamos las respuestas por defecto para las demás opciones menos para lo si-

guiente:

Cuando se te pregunte acerca de:

G4VIS_BUILD_OPENGLX_DRIVER G4VIS_USE_OPENGLX

Debes ingresar: y Con esta opción le decimos a Geant4 que incluya la herra-

mienta de visualización OpenGL

Tambien cuando se te pregunte acerca de:

G4VIS_BUILD_RAYTRACERX_DRIVER G4VIS_USE_RAYTRACERX

Debes de ingresar: y Con esta opción le decimos a Geant4 que incluya la

herramienta de visualización opcional RayTracerX. Para las demás preguntas se

toman todas las respuestas por defecto pulsando enter. Una vez todas las respues-

tas sean contestadas recibiras el siguiente mensaje:

WARNING: the generated configuration file can be edited if

necessary! You can introduce any change to the configuration file

/home/andres/Simulacion/geant4/geant4.9.0/.config/bin/Linux-g++/config.sh

before the final installation. To do so, use a shell escape now

(e.g. !vi

/home/andres/Simulacion/geant4/geant4.9.0/.config/bin/Linux-g++/config.sh).

Press [Enter] to start installation or use a shell escape to edit

config.sh:

A.7 70

Debemos presionar enter, y deberemos de obtener:

Now starting Geant4 libraries build...

On this machine the G4SYSTEM=Linux-g++ On this machine the

G4INSTALL=/home/andres/Simulacion/geant4.9.0/ On this machine the

G4TMP=/home/andres/Simulacion/geant4.9.0/tmp On this machine the

G4LIB=/home/andres/Simulacion/geant4.9.0/lib On this machine the

G4LEVELGAMMADATA=/home/andres/Simulacion/geant4.9.0/data/PhotonEvaporation2.0

On this machine the

G4RADIOACTIVEDATA=/home/andres/Simulacion/geant4.9.0/data/RadioactiveDecay3.2

On this machine the

G4LEDATA=/home/andres/Simulacion/geant4.9.0/data/G4EMLOW4.3 On this

machine the

G4NEUTRONHPDATA=/home/andres/Simulacion/geant4.9.0/data/G4NDL3.11 On

this machine the CLHEP_BASE_DIR=/home/andres/Simulacion/CLHEP On

this machine the

CLHEP_INCLUDE_DIR=/home/andres/Simulacion/CLHEP/include On this

machine the CLHEP_LIB_DIR=/home/andres/Simulacion/CLHEP/lib On this

machine the CLHEP_LIB=CLHEP On this machine the

G4VIS_BUILD_OPENGLX_DRIVER=1 On this machine the

G4VIS_BUILD_RAYTRACERX_DRIVER=1 On this machine the

G4VIS_USE_OPENGLX=1 On this machine the G4VIS_USE_RAYTRACERX=1 On

this machine the XMFLAGS= On this machine the XMLIBS= On this

machine the XMFLAGS= On this machine the XAWFLAGS= On this machine

the XAWLIBS= On this machine the G4LIB_BUILD_STATIC=1 On this

machine the G4LIB_USE_GRANULAR=1

Starting build...

*************************************************************

Installation Geant4 version : geant4-09-00

Copyright (C) 1994-2007 Geant4 Collaboration

*************************************************************

Making dependency for file src/G4ios.cc ... Making dependency for

A.7 71

file src/G4coutDestination.cc ... Making dependency for file

src/G4VStateDependent.cc ... Making dependency for file

src/G4VNotifier.cc ... Making dependency for file

src/G4VExceptionHandler.cc ... Making dependency for file

src/G4UnitsTable.cc ... Making dependency for file src/G4Timer.cc

... Making dependency for file src/G4StateManager.cc ... Making

dependency for file src/G4SliceTimer.cc ... Making dependency for

file src/G4PhysicsVector.cc ... Making dependency for file

src/G4PhysicsTable.cc ... Making dependency for file

src/G4PhysicsOrderedFreeVector.cc ... Making dependency for file

src/G4PhysicsLogVector.cc ... Making dependency for file

src/G4PhysicsLnVector.cc ... Making dependency for file

src/G4PhysicsLinearVector.cc ... Making dependency for file

src/G4PhysicsFreeVector.cc ... Making dependency for file

src/G4OrderedTable.cc ... Making dependency for file

src/G4LPhysicsFreeVector.cc ... Making dependency for file

src/G4GeometryTolerance.cc ... Making dependency for file

src/G4Exception.cc ... Making dependency for file

src/G4ErrorPropagatorData.cc ... Making dependency for file

src/G4DataVector.cc ... Making dependency for file

src/G4AllocatorPool.cc ... Compiling G4AllocatorPool.cc ...

Compiling G4DataVector.cc ... Compiling G4ErrorPropagatorData.cc ...

Compiling G4Exception.cc ...

Si encuentras líneas como:

Compiling G4AllocatorPool.cc ...

Sin ningun error signica que la compilación está corriendo sin problemas.

En este paso debes esperar bastante tiempo hasta que la compilación se termine,

debes de congurar la computadora para que no se vaya a hibernar; puedes salir

a dar una vuelta y comer algo.

Finalmente cuando se termine el proceso deberás observar lo siguiente:

Libmap stage. Searching for GNUmakefiles and sorting ... Weeding out

paths and files ... Making libname.map starter file ... Making

libname.map ...

A.8 72

Reading library name map file...

Reading dependency files...

Checking for circular dependencies...

Reordering according to dependencies...

Writing new library map file...

Libraries installation completed !

#################################################### # Your Geant4

installation seems to be successful! # To be sure please have a look

into the log file: #

/home/andres/Simulacion/geant4/geant4.9.0/.config/bin/Linux-g++/g4make.log

Con esto ya tienes geant4 instalado en tu PC.

A.8. Congurando el archivo fuente

Ahora debemos congurar algunas variables de entorno emplearemos en futu-

ras sesiones cuando usemos Geant, para hacerlo escribimos:

./Configure

Deberás de obtener lo siguiente:

--- Geant4 Toolkit Installation ---

(setting environments for USER )

---------------------------------------------------

The Geant4 toolkit installation was found. The files env.[c]sh will

be copied to your current directory. For setting Geant4 environments

you should make:

source env.csh or . env.sh

It will also check G4WORKDIR setting and set it to your HOME if

needed. You can use these files also for further modifications

(adding your own environments).

A.8 73

Tu directorio de geant que para nuestro ejemplo sería /home/andres

/Simulacion/geant4/geant4.9.0/ Debe de contener los siguientes archivos:

env.sh y env.csh

Con esto nalizamos la instalación de Geant4

Apéndice B

¾Cómo correr un ejemplo en

Geant4?

B.1. Creando el directorio de trabajo

Una vez que se haya realizado la instalación procedemos a correr un ejemplo

para comprobar que Geant4 quedó bien instalado. Primero vamos a crear un

directorio que quede fuera del área de instalación de Geant4 (Simulacion/geant4,

ver Como instalar Geant4. El tener una carpeta separada del área de instalación

nos evita que borremos o alteremos archivos importantes para el funcionamiento

de Geant4 y también nos permite realizar actualizaciones del programa sin alterar

las aplicaciones que estamos haciendo con Geant4. A esta carpeta donde estará

contenido tu trabajo con Geant4 la denominaremos g4work, luego deberás crear

esta carpeta en el directorio Simulacion tratado en la sección `Como instalar

geant4. Geant4 conoce el directorio de trabajo por el nombre de G4WORKDIR,

por lo que le tenemos que informar en qué parte queda nuestro directorio de

trabajo. En nuestro caso, la ruta completa para nuestro directorio de trabajo es:

/home/andres/Simulacion/g4work, entonces tenemos que ingresar lo siguiente:

export G4WORKDIR=/home/andres/Simulacion/g4work

B.2. Seleccionando una aplicación de ejemplo

En el área de instalación de Geant4 encontraremos una carpeta que está llena

de ejemplos, en este caso vamos a escoger uno de ellos para probar que nuestra

B.3 75

instalación fue correcta. Buscamos la carpeta Simulacion/geant4/geant4.9.0

/examples/extended/analysis/A01 y la copiamos a nuestro directorio de trabajo;

la forma de hacerlo con la terminal es usando el comando cp para la cual debemos

de ingresar:

cp -r /home/andres/Simulacion/geant4/geant4.9.0/

examples/extended/analysis/A01 $G4WORKDIR/A01

B.3. Congurando el ambiente de Geant4

Posteriormente le vamos a indicar a Geant4 dónde quedan las librerías para

altas energías (CLHEP) ingresando lo siguiente:

export LD_LIBRARY_PATH=/home/andres/Simulacion/CLHEP/

lib/:$LD_LIBRARY_PATH

Ahora le indicamos a Geant4 cuál es el archivo fuente, para lo cual debemos

de ingresar lo siguiente:

source /home/andres/Simulacion/geant4/geant4.9.0/env.sh

A lo cual deberas de recibir la siguiente respuesta:

On this machine the G4SYSTEM=Linux-g++ On this machine the

G4INSTALL=/home/andres/Simulacion/geant4.9.0 On this machine the

G4TMP=/home/andres/Simulacion/geant4.9.0/tmp On this machine the

G4LIB=/home/andres/Simulacion/geant4.9.0/lib On this machine the

G4LEVELGAMMADATA=/home/andres/Simulacion/geant4.9.0/data

/PhotonEvaporation2.0

On this machine the

G4RADIOACTIVEDATA=/home/andres/Simulacion/geant4.9.0/data

/RadioactiveDecay3.2

On this machine the

G4LEDATA=/home/andres/Simulacion/geant4.9.0/data/G4EMLOW4.3 On this

B.4 76

machine the

G4NEUTRONHPDATA=/home/andres/Simulacion/geant4.9.0/data/G4NDL3.11 On

this machine the CLHEP_BASE_DIR=/home/andres/Simulacion/CLHEP On

this machine the

CLHEP_INCLUDE_DIR=/home/andres/Simulacion/CLHEP/include On this

machine the CLHEP_LIB_DIR=/home/andres/Simulacion/CLHEP/lib On this

machine the CLHEP_LIB=CLHEP On this machine the

G4VIS_BUILD_OPENGLX_DRIVER=1 On this machine the

G4VIS_BUILD_RAYTRACERX_DRIVER=1 On this machine the

G4VIS_USE_OPENGLX=1 On this machine the G4VIS_USE_RAYTRACERX=1 On

this machine the XMFLAGS= On this machine the XMLIBS= On this

machine the XMFLAGS= On this machine the XAWFLAGS= On this machine

the XAWLIBS= On this machine the G4LIB_BUILD_STATIC=1 On this

machine the G4LIB_USE_GRANULAR=1

B.4. Construyendo la aplicación de ejemplo

Una vez que ya conguramos el ambiente procedemos a construir el ejecutable

de la aplicación de ejemplo que escogimos, que en este caso se denomina A01

y se encuentra en nuestra carpeta de trabajo g4work. Para crear el ejecutable

ingresamos lo siguiente:

cd $G4WORKDIR/A01 make

Deberías de recibir la siguiente respuesta:

Making dependency for file A01app.cc ... Making dependency for file

src/A01Trajectory.cc ... Making dependency for file

src/A01PrimaryGeneratorMessenger.cc ... Making dependency for file

src/A01PrimaryGeneratorAction.cc ... Making dependency for file

src/A01PhysicsList.cc ...

Que nalizaría con lo siguiente:

B.5 77

Compiling A01Trajectory.cc ... Creating/replacing object files in

/u/ey/perl/g4work/tmp/Linux-g++/A01app/libA01app.a ... Compiling

A01app.cc ... Using granular libraries ... Linking A01app ...

Si todo salió bien deberías de observar una carpeta nueva en tu directorio de

trabajo g4work que contenga lo siguiente: g4work/bin/Linux-g++/A01app

B.5. Corriendo el ejemplo

Para correr el ejemplo A01 ingresamos al directorio creado en el paso anterior,

para lo cual ingresamos:

cd /home/andres/Simulacion/g4work/bin/Linux-g++/

y luego corremos el ejemplo que es un archivo ejecutable, para lo cual ingre-

samos:

A01app

Con lo que deberíamos de recibir la siguiente respuesta:

*************************************************************

Geant4 version Name: geant4-09-00 (29-June-2007)

Copyright : Geant4 Collaboration

Reference : NIM A 506 (2003), 250-303

WWW : http://cern.ch/geant4

*************************************************************

Visualization Manager instantiating... Visualization Manager

initialising... Registering graphics systems...

You have successfully registered the following graphics systems.

B.5 78

Current available graphics systems are:

ASCIITree (ATree)

DAWNFILE (DAWNFILE)

GAGTree (GAGTree)

G4HepRep (HepRepXML)

G4HepRepFile (HepRepFile)

RayTracer (RayTracer)

VRML1FILE (VRML1FILE)

VRML2FILE (VRML2FILE)

OpenGLImmediateX (OGLIX)

OpenGLStoredX (OGLSX)

RayTracerX (RayTracerX)

Que nalizaría con lo siguiente:

EMcalorimeterPhysical[0] EMcalorimeterLogical 1 CsI

cellPhysical[-1] cellLogical 0 CsI /EMcalorimeter

HadCalorimeterPhysical[0] HadCalorimeterLogical 1 Lead

HadCalColumnPhysical[-1] HadCalColumnLogical 1 Lead

HadCalCellPhysical[-1] HadCalCellLogical 1 Lead

HadCalLayerPhysical[-1] HadCalLayerLogical 1 Lead

HadCalScintiPhysical[0] HadCalScintiLogical 0

Scintillator /HadCalorimeter

Idle>

Asegúrese de que en esta respuesta que se obtiene en la terminal se mencionen

los sistemas de grácas de Geant4 con lo siguiente:

OpenGLImmediateX (OGLIX) OpenGLStoredX (OGLSX)

Si no hay ninguna mención de estos sistemas de grácas signica que se cometió

algun error en la instalación de Geant4. Por lo que debes de mirar la sección Como

instalar Geant4. Asumiendo que tienes instalado el sistema de grácas OpenGL,

seguiremos los siguientes pasos:

Para visualizar el ejemplo ingresa:

B.5 79

Figura B.1: Imagen obtenida de geant4

/vis/open OGLIX

/vis/drawVolume

Con lo que debes de obtener la siguiente respuesta:

Got standard cmap Window name: viewer-0 (OpenGLImmediateX)

Además se debe de abrir una ventana nueva donde aparezca dibujada la geo-

metría del ejemplo como en la gura B.1.

Para añadir las trayectorias y la incidencia de las particulas presentes en el

ejemplo a la visualización ingresamos:

/vis/scene/add/trajectories

/vis/scene/add/hits

Para hacer incidir una particula ingresamos

/run/beamOn 1

Con lo que deberás de obtener algo similar a lo que se ve en la gura B.2

Para terminar la sesión de Geant4 ingresamos: exit

B.5 80

Figura B.2: Imagen obtenida de geant4

Apéndice C

Manual de instalación del interfaz

aida

El interfaz aida es una forma de obtener histogramas y scatter plots con los

resultados de geant4. Este interfaz funciona desde geant4, por lo que ahorra tiem-

po de computo, debido a que funciona paralelamente con geant4, y no hay que

correr un proceso adicional para obtener los histogramas.

C.1. Bajando los paquetes necesarios

Inicialmente tienen que bajar todos los paquetes necesarios para la instalación.

a) Bajan Java de cualquiera de las siguientes paginas

http://www.lewatcher.com/b/ftp/ftp.mv.ru/pub/Java/JDK2.0.0.html

http://mmc2.igeofcu.unam.mx/utils/Java/JDK/

Tienen que bajar el archivo que se llama: jdk-6u5-linux-x64.bin

Pueden darle click derecho y guardar enlace como... y aceptar.

b) Bajar jaida de la siguiente página

http://java.freehep.org/jaida/getting-started.html

C.3 82

Deben de bajar los siguientes archivos:

jaida-3.3.0-6-bin.tar.gz

jaida-3.3.0-6-i386-Linux-g++.tar.gz

c) Bajar aidajni de la siguiente pagina

ftp://ftp.slac.stanford.edu/software/freehep/AIDAJNI/v3.2.6/

Deben de bajar los siguientes archivos:

aidajni-3.2.6-amd64-Linux-g++.tar.gz

aidajni-3.2.6-doc.tar.gz

d) Bajar Jas de la siguiente pagina

http://jas.freehep.org/jas3/download.html

Deben de bajar el archivo del link que dice: Linux (.tar.gz) que se llama:

jas3-Linux-0.8.3.tar.gz

C.2. Creando la estructura de directorios

Ahora, vamos a crear la siguiente estructura de directorios para los paquetes

que bajamos de internet.

Van a crear una carpeta que se llama: aida en su carpeta personal.

En esa carpeta van a crear cuatro carpetas con los siguientes nombres:

java

jas3

jaida

aidajni

En cada una de estas carpetas guardan los instaladores correspondientes; es

decir, en la carpeta java guardan el archivo que bajaron de java; en la carpeta

jaida guardan los dos archivos que bajaron de jaida y asi sucesivamente.

C.3 83

C.3. Descomprimiendo los instaladores

El siguiente paso es descomprimir cada uno de los archivos una vez estén

ubicados en sus carpetas respectivas.

Para descomprimir java deben de ingresar a la carpeta java usando la terminal.

El archivo que van a descomprimir termina en .bin, luego el proceso de descom-

presión es distinto al de los archivos que terminan en tar.gz. Para descomprimir

el archivo .bin deben ingresar lo siguiente:

chmod a+x jdk-6u5-linux-x64.bin

./jdk-6u5-linux-x64.bin

Al hacer esto les aparecerá una licencia sobre Java, aquí presionamos q para

continuar el proceso. Luego les preguntarán si están de acuerdo con los términos

de la licencia, deben ingresar: yes Y luego presionan Enter.

Una vez hacen esto comienza el proceso de descompresión que debe de nalizar

con lo siguiente:

If your configuration supports a browser, the Sun Product

Registration form for the JDK will be presented. You may also

register your JDK later by opening the register.html file (located

in the JDK installation directory) in a browser. For more

information on what data Registration collects and how it is managed

and used, see:

http://java.sun.com/javase/registration/JDKRegistrationPrivacy.html

Press Enter to continue.....

Presionan enter. Para comprobar que todo está bien, en su directorio de java

debe de aparecer una carpeta nueva que se llama jdk1.6.0_05 que debe de con-

tener cerca de 168.2 Mb. Los demás archivos son de terminación tar.gz. Entonces

el proceso de descompresión que se sigue es el mismo para todos los archivos. Por

ejemplo para descomprimir el archivo que se encuentra en la carpeta jas3 deben

de ingresar:

C.5 84

tar -zxvf jas3-Linux-0.8.3.tar.gz

Y así deben hacer con los archivos de las otras carpetas (jaida y aidajni).

C.4. Usando jas3 y java

Después de descomprimir todo vamos a comenzar a utilizar jas3 y java para

comprobar que el proceso de descompresión fue exitoso.

Deben ingresar lo siguiente, que en mi caso sería

PATH=$PATH:/home/andres/aida/java/jdk1.6.0_05/bin/

Ya que mi carpeta personal es /home/andres

En su caso deben ingresar la ruta completa hasta la carpeta bin que se

encuentra en la carpeta jdk1.6.0_05 después de escribir PATH=$PATH: sin

dejar espacio.

Luego deben de ingresar a la carpeta jas3-0.8.3 que se encuentra en la carpeta

jas3 e ingresar:

./jas3

Y se les debe de abrir una ventana similar a la gura C.1

Una vez vean la imagen signica que ya tienen instalado Java y jas3.

C.5. Usando jaida, aidajni y java

Ahora vamos a usar jaida y aidajni junto con java.

Ingresamos

export JDK_HOME=/home/andres/aida/java/jdk1.6.0_05/

para mi caso, en el caso de ustedes deben ingresar la ruta completa hasta que

lleguen al directorio jdk1.6.0_05 es decir, ingresan:

export JDK_HOME= ∼ /aida/java/jdk1.6.0_05/

C.5 85

Figura C.1: Ventana de Jas3.

donde ∼ signica que deben de ingresar la ruta completa (Tengan en cuenta

esto de aquí en adelante).

Luego ingresan:

export JAIDA_HOME=∼ /aida/jaida/jaida-3.3.0-6/ source $JAIDA_HOME/bin/aida-

setup.sh

export AIDAJNI_HOME=∼/aida/aidajni/aidajni-3.2.6

source $AIDAJNI_HOME/bin/amd64-Linux-g++/aidajni-setup.sh

PATH=$PATH:∼/aida/java/jdk1.6.0_05/bin/

Ahora vamos correr un ejemplo.

Si todo salió bien al ingresar

aida-cong −−version

C.6 86

Le mostrara la versión de aida instalada, en este caso debe de mostrar: 3.2.6

y al ingresar

aida-cong −−include

Debe de mostrar:

-I/home/andres/aidajni/aidajni-3.2.6/include (en mi caso, en el caso de ustedes

la ruta inicial /home/andres/ será distinta) y al ingresar

aida-cong −−lib

Debe de mostrar:

-L/home/andres/aidajni/aidajni-3.2.6/lib/amd64-Linux-g++

-lfreehep-aidajni-3.2.6

-L/home/andres/java/jdk1.6.0_05//jre/lib/amd64/server -ljvm

C.6. Corriendo un ejemplo

Para correr un ejemplo donde se emplea Aida vayan a su carpeta personal e

ingresen

g++ -c `aida-cong include`∼/aida/aidajni/aidajni-3.2.6/examples/AidaTest.cpp

En la carpeta donde escribieron lo anterior (es decir su carpeta personal) apa-

recerá un archivo llamado: AidaTest.o

C.6 87

Ahora ingresen:

g++ -o AidaTest AidaTest.o `aida-cong lib`

Aparecerá un archivo llamado: AidaTest. Con esto nalmente ya tienen el in-

terfaz Aida instalado correctamente. Felicitaciones ½½½½½½½½½½½½½

Cada vez que vayan a correr geant4 junto con el interfaz aida deben de ingresar

lo siguiente a la terminal (adicional a los comandos que deben de ingresar para

que geant4 funcione)

export JDK_HOME=∼/aida/java/jdk1.6.0_05/

export JAIDA_HOME=∼/aida/jaida/jaida-3.3.0-6/

source $JAIDA_HOME/bin/aida-setup.sh

export AIDAJNI_HOME=∼/aida/aidajni/aidajni-3.2.6

source $AIDAJNI_HOME/bin/amd64-Linux-g++/aidajni-setup.sh


export G4ANALYSIS_USE=1

Una vez instalado el interfaz pueden correr ejemplos de geant4 que incluyan el

interfaz aida, esos ejemplos los pueden encontrar en la siguiente carpeta de geant:

geant4/geant4.9.0/examples/extended/analysis/

Corran el ejemplo de la carpeta A01/ (para correr el ejemplo recuerden mirar

la sección Como correr un ejemplo en geant4).

Una vez lo corren se debe de abrir una ventana con grácos. Luego, cuando la

terminal diga

C.6 88

Idle>

ingresen

/run/beamOn 5

y miren los grácos producidos en la ventana que se llama Plotter.

Al salir del ejemplo en la carpeta bin/Linux-g++/ debe de aparecer un archivo

llamado A01.aida este archivo lo pueden abrir si quieren en otra terminal o en la

misma ingresando:


donde ∼ signica que deben de ingresar la ruta completa es decir para mi ca-

so sería /home/andres..../etcetera.

Luego deben de ingresar a la carpeta jas3-0.8.3 que se encuentra en la carpeta

jas3 e ingresar:

./jas3

Y luego abren con el programa el archivo A01.aida y pueden ver las grácas...

Prueben correr otros ejemplos como AnaEx01/ que también está en la carpeta

analysis.

Prueben mirar varios ejemplos que contengan el interfaz Aida...

Dentro de esos ejemplos miren y analicen los siguientes:

eventgenerator/exgps

polarisation/

Apéndice D

Clases implementadas para la

simulación de la placa de aluminio

Aquí vamos a mostrar las clases implementadas para la simulación de la in-cidencia de muones de 1 GeV sobre una placa de aluminio como se explica en lasección "Simulación de una placa de aluminio".

Cualquier aplicación de Geant4 debe de contener un directorio principal con 2directorios (include y src) y dos archivo, el ejecutable (GNUmakele) y el archivoprincipal.

La carpeta principal donde se encuentra todo la aplicación para simular la in-cidencia de la placa de aluminio se llama: "Simulacion Aluminio".

D.1. Archivo Principal: pol01.cc

#include "G4RunManager.hh" #include "G4UImanager.hh" #include

"G4UIterminal.hh" #include "G4UItcsh.hh" #include "Randomize.hh"

#include "DetectorConstruction.hh" #include "PhysicsList.hh"

#include "PrimaryGeneratorAction.hh"

#include "RunAction.hh" #include "EventAction.hh" #include

"SteppingAction.hh" #include "HistoManager.hh"

#ifdef G4VIS_USE

D.1 90

#include "G4VisExecutive.hh"

#endif

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

int main(int argc,char** argv)

//choose the Random engine

// CLHEP::HepRandom::setTheEngine(new CLHEP::RanecuEngine);

// CLHEP::HepRandom::setTheEngine(new CLHEP::RanluxEngine());

// Construct the default run manager

G4RunManager * runManager = new G4RunManager;

// set mandatory initialization classes

DetectorConstruction* det;

PrimaryGeneratorAction* prim;

runManager->SetUserInitialization(det = new DetectorConstruction);

runManager->SetUserInitialization(new PhysicsList);

runManager->SetUserAction(prim = new PrimaryGeneratorAction);

//runManager->SetUserAction(prim = new PrimaryGeneratorAction(det));

G4VisManager* visManager = 0;

HistoManager* histo = new HistoManager();

// set user action classes

RunAction* run;

runManager->SetUserAction(run = new RunAction(det,prim,histo));

runManager->SetUserAction(new EventAction(run));

runManager->SetUserAction(new SteppingAction(det,prim,run,histo));

// get the pointer to the User Interface manager

G4UImanager* UI = G4UImanager::GetUIpointer();

if (argc==1) // Define UI terminal for interactive mode

#ifdef G4VIS_USE

// visualization manager

visManager = new G4VisExecutive;

visManager->Initialize();

#endif

G4UIsession * session = 0;

D.2 91

#ifdef G4UI_USE_TCSH

session = new G4UIterminal(new G4UItcsh);

#else

session = new G4UIterminal();

#endif

session->SessionStart();

delete session;

else // Batch mode

G4String command = "/control/execute ";

G4String fileName = argv[1];

UI->ApplyCommand(command+fileName);

// job termination

if(visManager) delete visManager;

delete histo;

delete runManager;

return 0;


D.2. Ejecutable: GNUmakele

--------------------------------------------------------------

name := pol01 G4TARGET := $(name) G4EXLIB := true

ifndef G4INSTALL

G4INSTALL = ../../../..

endif

.PHONY: all all: lib bin

include $(G4INSTALL)/config/binmake.gmk

ifdef G4ANALYSIS_USE

# for the aida-config command see the README file

CPPFLAGS += `aida-config --include`

LDLIBS += `aida-config --lib`

D.3 92

plots: plotResults.class

@echo calling JAIDA ...

java -cp .:$(CLASSPATH) plotResults pol01.aida

plotResults.class: plotResults.java

@echo compiling $<

javac $<

endif

D.3. Archivos contenidos en la carpeta src

D.3.1. DetectorConstruction.cc

#include "DetectorConstruction.hh"

#include "DetectorMessenger.hh"

//#include "ExN01MagneticField.hh"

//#include "ExN01ElectricFieldSetup.hh"

#include "G4Material.hh"

#include "G4Box.hh"

#include "G4Tubs.hh"

#include "G4LogicalVolume.hh"

#include "G4ThreeVector.hh"

#include"G4PVPlacement.hh"

#include "globals.hh"

#include "G4NistManager.hh"

#include "G4FieldManager.hh"

#include "G4PVParameterised.hh"

#include "G4SDManager.hh"

#include "G4GeometryTolerance.hh"

#include "G4GeometryManager.hh"

#include "G4UserLimits.hh"

#include "G4VisAttributes.hh" #include "G4Colour.hh"

#include "G4ios.hh"

D.3 93

DetectorConstruction::DetectorConstruction()

: VolumenGeneral_log(0), Aluminio_log(0), CorreccionAngulo_log(0),

VolumenGeneral_phys(0),

Aluminio_phys(0), CorreccionAngulo_phys(0)

// fEmFieldSetup(0)

// fpMagField(0)

// fpMagField = new ExN01MagneticField();

detectorMessenger = new DetectorMessenger(this);

//fEmFieldSetup = new ExN01ElectricFieldSetup() ;

DetectorConstruction::~DetectorConstruction()

//delete fpMagField;

delete detectorMessenger;

// delete fEmFieldSetup ;

G4VPhysicalVolume* DetectorConstruction::Construct()

//------------------------------------------------------ materials

//G4String symbol;

G4double a, z, density; //z=mean number of protons;

//iz=number of protons in an isotope;

// n=number of nucleons in an isotope;

/* G4int ncomponents, natoms;

G4Element* H = new G4Element("Hydrogen",symbol="H" , z= 1., a=

1.01*g/mole); G4Element* C = new G4Element("Carbon" ,symbol="C" ,

z= 6., a= 12.01*g/mole);

//G4Element* N = new G4Element("Nitrogen",symbol="N" , z= 7., a= 14.01*g/mole);

//G4Element* O = new G4Element("Oxygen" ,symbol="O" , z= 8., a= 16.00*g/mole);

G4Element* F = new G4Element("Fluor",symbol="F" , z= 9., a=

19.00*g/mole);

D.3 94

G4Material* C2H2F4 = new G4Material("GasEnRpc", density=

4089.26*g/m3, ncomponents=3, kStateGas, 300.*kelvin, 1.*bar);

C2H2F4->AddElement(C, natoms=2); C2H2F4->AddElement(H, natoms=2);

C2H2F4->AddElement(F, natoms=4);

*/

G4Material* Al = new G4Material("Aluminum", z= 13., a= 26.98*g/mole,

density= 2.7*g/cm3);

G4NistManager* man = G4NistManager::Instance();

G4Material* MAir = man->FindOrBuildMaterial("G4_AIR");

//G4Material* MBak = man->FindOrBuildMaterial("G4_BAKELITE");

//G4Material* MGraf = man->FindOrBuildMaterial("G4_GRAPHITE");

//G4Material* MPoli = man->FindOrBuildMaterial("G4_POLYETHYLENE");

//------------------------------------------------------Volumenes

//------------------------------ Volumen general de Aluminio

G4double VolGen_x = 15.5*cm;

G4double VolGen_y = 15.5*cm;

G4double VolGen_z = 2.0*cm;

G4Box* VolumenGeneral_box

= new G4Box("VolGen_box",VolGen_x,VolGen_y,VolGen_z);

VolumenGeneral_log = new G4LogicalVolume(VolumenGeneral_box,

MAir,"VolGen_log",0,0,0);

VolumenGeneral_phys = new G4PVPlacement(0,G4ThreeVector(),

VolumenGeneral_log,"VolGen",0,false,0);

/*

//------------------------------ Capas de Baquelita

G4double baque_x = 15.0*cm;

G4double baque_y = 15.0*cm;

G4double baque_z = 1.0*mm;

G4Box* Baquelita_box = new G4Box("Baque_box",baque_x,

D.3 95

baque_y,baque_z);

Baquelita_log = new G4LogicalVolume(Baquelita_box,

MBak,"Baque_log",0,0,0);

G4double baquePos1_x = 0.0*mm;

G4double baquePos1_y = 0.0*mm;

G4double baquePos1_z = 2.0*mm;

Baquelita_phys = new G4PVPlacement(0,

G4ThreeVector(baquePos1_x,baquePos1_y,baquePos1_z),

Baquelita_log,"Baque",VolumenGeneral_log,false,0);



G4double baquePos2_z = -2.0*mm;




//------------------------------ Capas de Grafito

G4double grafi_x = 15.0*cm;

G4double grafi_y = 15.0*cm;

G4double grafi_z = 0.1*mm;

G4Box* Grafito_box = new G4Box("Grafi_box",grafi_x,

grafi_y,grafi_z);

Grafito_log = new G4LogicalVolume(Grafito_box,

MGraf,"Grafi_log",0,0,0);

G4double grafiPos1_x = 0.0*mm;

G4double grafiPos1_y = 0.0*mm;

G4double grafiPos1_z = 3.1*mm;

Grafito_phys = new G4PVPlacement(0,

G4ThreeVector(grafiPos1_x,grafiPos1_y,grafiPos1_z),

Grafito_log,"Grafi",VolumenGeneral_log,false,0);



G4double grafiPos2_z = -3.1*mm;




//------------------------------ Capas de Polietileno

G4double poli_x = 15.0*cm;

D.3 96

G4double poli_y = 15.0*cm;

G4double poli_z = 0.1*mm;

G4Box* Polietileno_box = new G4Box("Poli_box",poli_x,

poli_y,poli_z);

Polietileno_log = new G4LogicalVolume(Polietileno_box,

MPoli,"Poli_log",0,0,0);

G4double PoliPos1_x = 0.0*mm;

G4double PoliPos1_y = 0.0*mm;

G4double PoliPos1_z = 3.3*mm;

Polietileno_phys = new G4PVPlacement(0,

G4ThreeVector(PoliPos1_x,PoliPos1_y,PoliPos1_z),

Polietileno_log,"Poli",VolumenGeneral_log,false,0);



G4double PoliPos2_z = -3.3*mm;




//------------------------------ Gas dentro de la camara

G4double gas_x = 15.0*cm;

G4double gas_y = 15.0*cm;

G4double gas_z = 1.0*mm;

G4Box* GasC2H2F4_box = new G4Box("Gas_box",gas_x,

gas_y,gas_z);

GasC2H2F4_log = new G4LogicalVolume(GasC2H2F4_box,

C2H2F4,"Gas_log",0,0,0);

G4double GasPos_x = 0.0*mm;

G4double GasPos_y = 0.0*mm;

G4double GasPos_z = 0.0*mm;

GasC2H2F4_phys = new G4PVPlacement(0,

G4ThreeVector(GasPos_x,GasPos_y,GasPos_z),

GasC2H2F4_log,"Gas",VolumenGeneral_log,false,0);

*/

//------------------------------ Capa de Aluminio

G4double alu_x = 15.0*cm;

G4double alu_y = 15.0*cm;

G4double alu_z = 1.5*mm;

G4Box* Aluminio_box = new G4Box("Alu_box",alu_x,

alu_y,alu_z);

D.3 97

Aluminio_log = new G4LogicalVolume(Aluminio_box,

Al,"Alu_log",0,0,0);

G4double AluPos_x = 0.0*mm;

G4double AluPos_y = 0.0*mm;

G4double AluPos_z = 0.0*mm;

Aluminio_phys = new G4PVPlacement(0,

G4ThreeVector(AluPos_x,AluPos_y,AluPos_z),

Aluminio_log,"Aluminio",VolumenGeneral_log,false,0);

//--- Capa de Aire para contar gammas, que solo tenga en cuenta los que

//-----salen y no los que se devuelven

G4double corre_x = 15.0*cm;

G4double corre_y = 15.0*cm;

G4double corre_z = 2.0*mm;

G4Box* CorrecionAngulo_box = new G4Box("Corre_box",corre_x,

corre_y,corre_z);

CorreccionAngulo_log = new G4LogicalVolume(CorrecionAngulo_box,

MAir,"Corre_log",0,0,0);

G4double CorrePos_x = 0.0*mm;

G4double CorrePos_y = 0.0*mm;

G4double CorrePos_z = -5.5*mm;

CorreccionAngulo_phys = new G4PVPlacement(0,

G4ThreeVector(CorrePos_x,CorrePos_y,CorrePos_z),

CorreccionAngulo_log,"CorreccionAngulo",VolumenGeneral_log,false,0);

G4VisAttributes* VolgenVisAtt= new G4VisAttributes(G4Colour(1.0,1.0,1.0));

VolumenGeneral_log ->SetVisAttributes(VolgenVisAtt);

G4VisAttributes* AlumVisAtt = new G4VisAttributes(G4Colour(1.0,0.0,0.0));

Aluminio_log ->SetVisAttributes(AlumVisAtt);

/* G4VisAttributes* atb= new

G4VisAttributes(G4Colour(1.0,0.0,0.0));

atb->SetForceSolid(true);

Aluminio_log ->SetVisAttributes(atb);

//Set opacity = 0.2 then transparency = 1 - 0.2 = 0.8

G4VisAttributes* atb= new G4VisAttributes(G4Colour(0.0,0.0,1.0,0.2));


logicGap->SetVisAttributes(atb);

D.3 98

*/

G4VisAttributes* atb= new G4VisAttributes(G4Colour(1.0,0.0,0.0,1.0));


Aluminio_log->SetVisAttributes(atb);

G4VisAttributes* atb= new G4VisAttributes(G4Colour(1.0,1.0,1.0));


CorreccionAngulo_log ->SetVisAttributes(atb);

return VolumenGeneral_phys;

//void ExN01DetectorConstruction::SetMagField(G4double fieldValue)

//

// fpMagField->SetFieldValue(fieldValue);

//

D.3.2. DetectorMessenger.cc


#include "DetectorConstruction.hh" #include "G4UIdirectory.hh"

#include "G4UIcmdWithAString.hh" #include

"G4UIcmdWithADoubleAndUnit.hh" #include "G4UIcmdWithoutParameter.hh"


DetectorMessenger::DetectorMessenger(DetectorConstruction * Det)

:Detector(Det)


DetectorMessenger::~DetectorMessenger()

D.3 99


void DetectorMessenger::SetNewValue(G4UIcommand*, G4String)


D.3.3. EventAction.cc

#include "EventAction.hh"

#include "EventActionMessenger.hh"

#include "G4Event.hh"

#include "G4TrajectoryContainer.hh"

#include "G4Trajectory.hh"

#include "G4VVisManager.hh"

#include "G4UnitsTable.hh"

#include "RunAction.hh"


EventAction::EventAction(RunAction * ra)

:printModulo(10000),eventMessenger(0),runAction(ra)

eventMessenger = new EventActionMessenger(this);


EventAction::~EventAction()

delete eventMessenger;


void EventAction::BeginOfEventAction(const G4Event* evt)

G4int evtNb = evt->GetEventID();

D.3 100

//printing survey

if (evtNb%printModulo == 0)

G4cout << "\n---> Begin of Event: " << evtNb << G4endl;


void EventAction::EndOfEventAction(const G4Event* evt)

if (runAction) runAction->EventFinished();

if (G4VVisManager::GetConcreteInstance())

G4TrajectoryContainer* trajectoryContainer = evt->GetTrajectoryContainer();

G4int n_trajectories = 0;

if (trajectoryContainer) n_trajectories = trajectoryContainer->entries();

for (G4int i=0; i<n_trajectories; i++)

G4Trajectory* trj = (G4Trajectory*)

((*(evt->GetTrajectoryContainer()))[i]);

trj->DrawTrajectory(1000);


D.3.4. EventActionMessenger.cc



#include "G4UIdirectory.hh" #include "G4UIcmdWithAnInteger.hh"


EventActionMessenger::EventActionMessenger(EventAction* EvAct)

:eventAction(EvAct)

eventDir = new G4UIdirectory("/testem/event/");

eventDir ->SetGuidance("event control");

PrintCmd = new G4UIcmdWithAnInteger("/testem/event/printModulo",this);

D.3 101

PrintCmd->SetGuidance("Print events modulo n");

PrintCmd->SetParameterName("EventNb",false);

PrintCmd->SetRange("EventNb>0");

PrintCmd->AvailableForStates(G4State_PreInit,G4State_Idle);


EventActionMessenger::~EventActionMessenger()

delete PrintCmd;

delete eventDir;


void EventActionMessenger::SetNewValue(G4UIcommand* command,

G4String newValue)

if (command == PrintCmd)

eventAction->SetPrintModulo(PrintCmd->GetNewIntValue(newValue));


D.3.5. HistoManager.cc

#include "HistoManager.hh" #include "HistoMessenger.hh" #include

"G4UnitsTable.hh"

#ifdef G4ANALYSIS_USE #include "AIDA/AIDA.h" #endif


HistoManager::HistoManager() :af(0),tree(0),factoryOn(false)

#ifdef G4ANALYSIS_USE

// Creating the analysis factory

af = AIDA_createAnalysisFactory();

if(!af)

G4cout << " HistoManager::HistoManager() :"

<< " problem creating the AIDA analysis factory."

<< G4endl;

#endif

D.3 102

fileName[0] = "pol01.aida";

fileType = "xml";

fileOption = "compress=yes";

// histograms

for (G4int k=0; k<MaxHisto; k++)

histo[k] = 0;

exist[k] = false;

Unit[k] = 1.0;

Width[k] = 1.0;

///////////Mi agregado

cloud=0;

////////////Mi agregado

histoMessenger = new HistoMessenger(this);


HistoManager::~HistoManager()

delete histoMessenger;


delete af;

#endif


void HistoManager::book() #ifdef G4ANALYSIS_USE

if(!af) return;

// Creating a tree mapped to an aida file.

if (fileName[0].find(".")==G4String::npos)

fileName[1] = fileName[0] + "." + fileType;

else

fileName[1] = fileName[0];

G4bool readOnly = false;

D.3 103

G4bool createNew = true;

AIDA::ITreeFactory* tf = af->createTreeFactory();

tree = tf->create(fileName[1], fileType, readOnly, createNew, fileOption);

delete tf;

if(!tree)

G4cout << "HistoManager::book() :"

<< " problem creating the AIDA tree with "

<< " storeName = " << fileName[1]

<< " storeType = " << fileType

<< " readOnly = " << readOnly

<< " createNew = " << createNew

<< " options = " << fileOption

<< G4endl;

return;

// Creating a histogram factory, whose histograms will be handled by the tree

AIDA::IHistogramFactory* hf = af->createHistogramFactory(*tree);

// create selected histograms


if (exist[k])

histo[k] = hf->createHistogram1D( Label[k], Title[k],

Nbins[k], Vmin[k], Vmax[k]);

factoryOn = true;


cloud=hf->createCloud2D( "Scatter Plot X vs Y");


delete hf;

if(factoryOn)

G4cout << "\n----> Histogram Tree is opened " << fileName[1] << G4endl;

#endif


void HistoManager::save() #ifdef G4ANALYSIS_USE

if (factoryOn)

tree->commit(); // Writing the histograms to the file

tree->close(); // and closing the tree (and the file)

G4cout << "\n----> Histogram Tree is saved in " << fileName[1] << G4endl;

D.3 104

delete tree;

tree = 0;

factoryOn = false;

#endif


void HistoManager::FillHistos(const G4String & particleName,

G4double kinEnergy, G4double costheta,

G4double phi,

G4double longitudinalPolarization,

////mi agregado

G4double posX, G4double posY

////mi agregado

)

G4int id=1;

if (particleName=="gamma")

id=1;


cloud->fill(posX, posY);


else if (particleName=="e-")

id=5;


//cloud->fill(posX, posY);


else if (particleName=="e+") id=9;

else return;

if (costheta>=1.) costheta=.99999999;

if (costheta<-1.) costheta=-1.;

FillHisto(id,kinEnergy);

FillHisto(id+1,costheta);

FillHisto(id+2,phi);

FillHisto(id+3,longitudinalPolarization);

D.3 105

void HistoManager::FillHisto(G4int ih, G4double e, G4double weight)

if (ih > MaxHisto)

G4cout << "---> warning from HistoManager::FillHisto() : histo " << ih

<< "does not exist; e= " << e << " w= " << weight << G4endl;

return;


if(exist[ih]) histo[ih]->fill(e/Unit[ih], weight);

#endif


void HistoManager::SetHisto(G4int ih, G4int nbins, G4double valmin,

G4double valmax, const G4String& unit)

if (ih > MaxHisto)

G4cout << "---> warning from HistoManager::SetHisto() : histo " << ih

<< "does not exist" << G4endl;

return;

const G4String id[] = "0", "1", "2", "3", "4", "5",

"6", "7", "8", "9", "10", "11", "12";

const G4String title[] =

"dummy", //0

"Gamma Energy distribution", //1

"Gamma Cos(Theta) distribution", //2

"Gamma Phi angular distribution", //3

"Gamma longitudinal Polarization", //4

"Electron Energy distribution", //5

"Electron Cos(Theta) distribution", //6

"Electron Phi angular distribution", //7

"Electron longitudinal Polarization", //8

"Positron Energy distribution", //9

"Positron Cos(Theta) distribution", //10

"Positron Phi angular distribution", //11

"Positron longitudinal Polarization" //12

;

G4String titl = title[ih];

G4double vmin = valmin, vmax = valmax;

Unit[ih] = 1.;

D.3 106

if (unit != "none")

titl = title[ih] + " (" + unit + ")";

Unit[ih] = G4UnitDefinition::GetValueOf(unit);

vmin = valmin/Unit[ih]; vmax = valmax/Unit[ih];

exist[ih] = true;

Label[ih] = id[ih];

Title[ih] = titl;

Nbins[ih] = nbins;

Vmin[ih] = vmin;

Vmax[ih] = vmax;

Width[ih] = (valmax-valmin)/nbins;

G4cout << "----> SetHisto " << ih << ": " << titl << "; "

<< nbins << " bins from "

<< vmin << " " << unit << " to " << vmax << " " << unit << G4endl;


void HistoManager::RemoveHisto(G4int ih)

if (ih > MaxHisto)

G4cout << "---> warning from HistoManager::RemoveHisto() : histo " << ih


return;

histo[ih] = 0; exist[ih] = false;


D.3.6. HistoMessenger.hh

#include "HistoMessenger.hh"

#include <sstream>

#include "HistoManager.hh" #include "G4UIdirectory.hh" #include

D.3 107

"G4UIcommand.hh" #include "G4UIparameter.hh" #include

"G4UIcmdWithAString.hh" #include "G4UIcmdWithAnInteger.hh"


HistoMessenger::HistoMessenger(HistoManager* manager) :histoManager

(manager)

histoDir = new G4UIdirectory("/testem/histo/");

histoDir->SetGuidance("histograms control");

factoryCmd = new G4UIcmdWithAString("/testem/histo/setFileName",this);

factoryCmd->SetGuidance("set name for the histograms file");

typeCmd = new G4UIcmdWithAString("/testem/histo/setFileType",this);

typeCmd->SetGuidance("set histograms file type");

typeCmd->SetCandidates("hbook root XML xml aida");

optionCmd = new G4UIcmdWithAString("/testem/histo/setFileOption",this);

optionCmd->SetGuidance("set option for the histograms file");

histoCmd = new G4UIcommand("/testem/histo/setHisto",this);

histoCmd->SetGuidance("Set bining of the histo number ih :");

histoCmd->SetGuidance(" nbBins; valMin; valMax; unit (of vmin and vmax)");

//

G4UIparameter* ih = new G4UIparameter("ih",'i',false);

ih->SetGuidance("histo number : from 1 to MaxHisto");

ih->SetParameterRange("ih>0");

histoCmd->SetParameter(ih);

//

G4UIparameter* nbBins = new G4UIparameter("nbBins",'i',false);

nbBins->SetGuidance("number of bins");

nbBins->SetParameterRange("nbBins>0");

histoCmd->SetParameter(nbBins);

//

G4UIparameter* valMin = new G4UIparameter("valMin",'d',false);

valMin->SetGuidance("valMin, expressed in unit");

histoCmd->SetParameter(valMin);

//

G4UIparameter* valMax = new G4UIparameter("valMax",'d',false);

valMax->SetGuidance("valMax, expressed in unit");

histoCmd->SetParameter(valMax);

//

G4UIparameter* unit = new G4UIparameter("unit",'s',true);

unit->SetGuidance("if omitted, vmin and vmax are assumed dimensionless");

D.3 108

unit->SetDefaultValue("none");

histoCmd->SetParameter(unit);

rmhistoCmd = new G4UIcmdWithAnInteger("/testem/histo/removeHisto",this);

rmhistoCmd->SetGuidance("desactivate histo #id");

rmhistoCmd->SetParameterName("id",false);

rmhistoCmd->SetRange("id>0");


HistoMessenger::~HistoMessenger()

delete rmhistoCmd;

delete histoCmd;

delete optionCmd;

delete typeCmd;

delete factoryCmd;

delete histoDir;


void HistoMessenger::SetNewValue(G4UIcommand* command, G4String

newValues)

if (command == factoryCmd)

histoManager->SetFileName(newValues);

if (command == typeCmd)

histoManager->SetFileType(newValues);

if (command == optionCmd)

histoManager->SetFileOption(newValues);

if (command == histoCmd)

G4int ih,nbBins; G4double vmin,vmax; char unts[30];

std::istringstream is(newValues.c_str());

is >> ih >> nbBins >> vmin >> vmax >> unts;

G4String unit = unts;

G4double vUnit = 1. ;

if (unit != "none") vUnit = G4UIcommand::ValueOf(unit);

histoManager->SetHisto (ih,nbBins,vmin*vUnit,vmax*vUnit,unit);

if (command == rmhistoCmd)

D.3 109

histoManager->RemoveHisto(rmhistoCmd->GetNewIntValue(newValues));


D.3.7. PhysicsList.hh

#include "globals.hh" #include "PhysicsList.hh"

#include "G4ProcessManager.hh" #include "G4ParticleTypes.hh"


PhysicsList::PhysicsList(): G4VUserPhysicsList()

defaultCutValue = 0.1*mm;

SetVerboseLevel(1);


PhysicsList::~PhysicsList()


void PhysicsList::ConstructParticle()

// In this method, static member functions should be called

// for all particles which you want to use.

// This ensures that objects of these particle types will be

// created in the program.

ConstructBosons();

ConstructLeptons();

ConstructMesons();

ConstructBaryons();


void PhysicsList::ConstructBosons()

// pseudo-particles

G4Geantino::GeantinoDefinition();

G4ChargedGeantino::ChargedGeantinoDefinition();

D.3 110

// gamma

G4Gamma::GammaDefinition();


void PhysicsList::ConstructLeptons()

// leptons

// e+/-

G4Electron::ElectronDefinition();

G4Positron::PositronDefinition();

// mu+/-

G4MuonPlus::MuonPlusDefinition();

G4MuonMinus::MuonMinusDefinition();

// nu_e

G4NeutrinoE::NeutrinoEDefinition();

G4AntiNeutrinoE::AntiNeutrinoEDefinition();

// nu_mu

G4NeutrinoMu::NeutrinoMuDefinition();

G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();


void PhysicsList::ConstructMesons()

// mesons

// light mesons

G4PionPlus::PionPlusDefinition();

G4PionMinus::PionMinusDefinition();

G4PionZero::PionZeroDefinition();

G4Eta::EtaDefinition();

G4EtaPrime::EtaPrimeDefinition();

G4KaonPlus::KaonPlusDefinition();

G4KaonMinus::KaonMinusDefinition();

G4KaonZero::KaonZeroDefinition();

G4AntiKaonZero::AntiKaonZeroDefinition();

G4KaonZeroLong::KaonZeroLongDefinition();

G4KaonZeroShort::KaonZeroShortDefinition();


void PhysicsList::ConstructBaryons()

D.3 111

// barions

G4Proton::ProtonDefinition();

G4AntiProton::AntiProtonDefinition();

G4Neutron::NeutronDefinition();

G4AntiNeutron::AntiNeutronDefinition();


void PhysicsList::ConstructProcess()

AddTransportation();

ConstructEM();

ConstructGeneral();


#include "G4ComptonScattering.hh" #include "G4GammaConversion.hh"

#include "G4PhotoElectricEffect.hh"

#include "G4MultipleScattering.hh"

#include "G4eIonisation.hh" #include "G4eBremsstrahlung.hh" #include

"G4eplusAnnihilation.hh"

#include "G4MuIonisation.hh" #include "G4MuBremsstrahlung.hh"

#include "G4MuPairProduction.hh"

#include "G4hIonisation.hh"

#include "G4StepLimiter.hh" #include "G4UserSpecialCuts.hh"


void PhysicsList::ConstructEM()

theParticleIterator->reset();

while( (*theParticleIterator)() )

G4ParticleDefinition* particle = theParticleIterator->value();

G4ProcessManager* pmanager = particle->GetProcessManager();

G4String particleName = particle->GetParticleName();

if (particleName == "gamma")

// gamma

D.3 112

pmanager->AddDiscreteProcess(new G4PhotoElectricEffect);

pmanager->AddDiscreteProcess(new G4ComptonScattering);

pmanager->AddDiscreteProcess(new G4GammaConversion);

else if (particleName == "e-")

//electron

pmanager->AddProcess(new G4MultipleScattering,-1, 1,1);

pmanager->AddProcess(new G4eIonisation, -1, 2,2);

pmanager->AddProcess(new G4eBremsstrahlung, -1, 3,3);

else if (particleName == "e+")

//positron




pmanager->AddProcess(new G4eplusAnnihilation, 0,-1,4);

else if( particleName == "mu+" ||

particleName == "mu-" )

//muon


pmanager->AddProcess(new G4MuIonisation, -1, 2,2);

pmanager->AddProcess(new G4MuBremsstrahlung, -1, 3,3);

pmanager->AddProcess(new G4MuPairProduction, -1, 4,4);

else if ((!particle->IsShortLived()) &&

(particle->GetPDGCharge() != 0.0) &&

(particle->GetParticleName() != "chargedgeantino"))

//all others charged particles except geantino


pmanager->AddProcess(new G4hIonisation, -1, 2,2);

//step limit

////pmanager->AddProcess(new G4StepLimiter, -1,-1,3);

///pmanager->AddProcess(new G4UserSpecialCuts, -1,-1,4);


#include "G4Decay.hh" void PhysicsList::ConstructGeneral()

// Add Decay Process

G4Decay* theDecayProcess = new G4Decay();


D.3 113




if (theDecayProcess->IsApplicable(*particle))

pmanager ->AddProcess(theDecayProcess);

// set ordering for PostStepDoIt and AtRestDoIt

pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);

pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);


void PhysicsList::SetCuts()

/*

if (verboseLevel >0)

G4cout << "ExN01PhysicsList::SetCuts:";

G4cout << "CutLength : " << G4BestUnit(defaultCutValue,"Length") << G4endl;

// set cut values for gamma at first and for e- second and next for e+,

// because some processes for e+/e- need cut values for gamma

//

SetCutValue(defaultCutValue, "gamma");

SetCutValue(defaultCutValue, "e-");

SetCutValue(defaultCutValue, "e+");

*/

//G4VUserPhysicsList::SetCutsWithDefault method sets

//the default cut value for all particle types

//

SetCutsWithDefault();

if (verboseLevel>0) DumpCutValuesTable();

D.3 114


D.3.8. PrimaryGeneratorAction.cc



#include "G4Event.hh" #include "G4ParticleGun.hh" #include

"G4ParticleTable.hh" #include "G4ParticleDefinition.hh" #include

"globals.hh"


PrimaryGeneratorAction::PrimaryGeneratorAction()

//PrimaryGeneratorAction::PrimaryGeneratorAction(DetectorConstruction* det)

//:detector(det)

particleGun = new G4ParticleGun(1);

G4ParticleDefinition*

particle= G4ParticleTable::GetParticleTable()->FindParticle("mu-");

particleGun->SetParticleDefinition(particle);

particleGun->SetParticleEnergy(1.0*GeV);

particleGun->SetParticleMomentumDirection(G4ThreeVector(0.,0.,-1.0));

/*

G4int n_particle = 1;

particleGun = new G4ParticleGun(n_particle);

// default particle

G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();

G4ParticleDefinition* particle = particleTable->FindParticle("proton");




*/

D.3 115


PrimaryGeneratorAction::~PrimaryGeneratorAction()

delete particleGun;


void PrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent)

//this function is called at the begining of event

//

particleGun->SetParticlePosition(G4ThreeVector(0.*cm,0.*cm,1.5*mm));

particleGun->GeneratePrimaryVertex(anEvent);


D.3.9. RunAction.cc


#include "DetectorConstruction.hh" #include

"PrimaryGeneratorAction.hh" #include "HistoManager.hh"

#include "G4Run.hh" #include "G4RunManager.hh" #include

"G4UnitsTable.hh" #include "G4EmCalculator.hh"

#include "Randomize.hh" #include <iomanip>


RunAction::RunAction(DetectorConstruction* det,

PrimaryGeneratorAction* prim,

HistoManager* histo)

: detector(det), primary(prim), ProcCounter(0), histoManager(histo)

totalEventCount=0;

D.3 116


RunAction::~RunAction()


void RunAction::BeginOfRunAction(const G4Run* aRun)

G4cout << "### Run " << aRun->GetRunID() << " start." << G4endl;

// save Rndm status

// G4RunManager::GetRunManager()->SetRandomNumberStore(false);

// CLHEP::HepRandom::showEngineStatus();

if (ProcCounter) delete ProcCounter;

ProcCounter = new ProcessesCount;

totalEventCount = 0;

photonStats.Clear();

electronStats.Clear();

positronStats.Clear();

histoManager->book();


void RunAction::FillData(const G4String & particleName,


G4double /* phi*/,

G4double longitudinalPolarization)


photonStats.FillData(kinEnergy, costheta, longitudinalPolarization);


electronStats.FillData(kinEnergy, costheta, longitudinalPolarization);

else if (particleName=="e+")

positronStats.FillData(kinEnergy, costheta, longitudinalPolarization);

void RunAction::CountProcesses(G4String procName)

// is the process already counted ?

// *AS* change to std::map?!

size_t nbProc = ProcCounter->size();

size_t i = 0;

while ((i<nbProc)&&((*ProcCounter)[i]->GetName()!=procName)) i++;

if (i == nbProc) ProcCounter->push_back( new OneProcessCount(procName));

D.3 117

(*ProcCounter)[i]->Count();


void RunAction::EndOfRunAction(const G4Run* aRun)

G4int NbOfEvents = aRun->GetNumberOfEvent();

if (NbOfEvents == 0) return;

G4int prec = G4cout.precision(5);

//G4Material* material = detector->GetMaterial();

//G4double density = material->GetDensity();

G4ParticleDefinition*

particle = primary->GetParticleGun()->GetParticleDefinition();

G4String Particle = particle->GetParticleName();

G4double energy = primary->GetParticleGun()->GetParticleEnergy();

G4cout << "\n The run consists of " << NbOfEvents << " "<< Particle << " of "

<< G4BestUnit(energy,"Energy") << " through " << G4endl;

//<< G4BestUnit(detector->GetBoxSizeZ(),"Length") << " of "

//<< material->GetName() << " (density: "

//<< G4BestUnit(density,"Volumic Mass") << ")" << G4endl;

//frequency of processes

G4cout << "\n Process calls frequency --->\n";

for (size_t i=0; i< ProcCounter->size();i++)

G4String procName = (*ProcCounter)[i]->GetName();

G4int count = (*ProcCounter)[i]->GetCounter();

G4cout << "\t" << procName << " = " << count<<"\n";

if (totalEventCount == 0) return;

G4cout<<" Gamma: \n";

photonStats.PrintResults(totalEventCount);

G4cout<<" Electron: \n";

electronStats.PrintResults(totalEventCount);

G4cout<<" Positron: \n";

positronStats.PrintResults(totalEventCount);

D.3 118

//cross check from G4EmCalculator

// G4cout << "\n Verification from G4EmCalculator. \n";

// G4EmCalculator emCal;

//restore default format

G4cout.precision(prec);

// write out histograms

histoManager->save();

// show Rndm status

CLHEP::HepRandom::showEngineStatus();


void RunAction::EventFinished()

++totalEventCount;

photonStats.EventFinished();

electronStats.EventFinished();

positronStats.EventFinished();


RunAction::ParticleStatistics::ParticleStatistics()

: currentNumber(0),

totalNumber(0), totalNumber2(0),

sumEnergy(0), sumEnergy2(0),

sumPolarization(0), sumPolarization2(0),

sumCosTheta(0), sumCosTheta2(0)


RunAction::ParticleStatistics::~ParticleStatistics()


void RunAction::ParticleStatistics::EventFinished()

totalNumber+=currentNumber;

totalNumber2+=currentNumber*currentNumber;

currentNumber=0;

D.3 119


void RunAction::ParticleStatistics:: FillData(G4double kinEnergy,

G4double costheta,


++currentNumber;

sumEnergy+=kinEnergy;

sumEnergy2+=kinEnergy*kinEnergy;

sumPolarization+=longitudinalPolarization;

sumPolarization2+=longitudinalPolarization*longitudinalPolarization;

sumCosTheta+=costheta;

sumCosTheta2+=costheta*costheta;


void RunAction::ParticleStatistics::PrintResults(G4int

totalNumberOfEvents)

G4cout<<"Mean Number per Event :"

<<G4double(totalNumber)/G4double(totalNumberOfEvents)<<"\n";

if (totalNumber==0) totalNumber=1;

G4double energyMean=sumEnergy/totalNumber;

G4double energyRms=std::sqrt(sumEnergy2/totalNumber-energyMean*energyMean);

G4cout<<"Mean Energy :"<< G4BestUnit(energyMean,"Energy")

<<" +- "<<G4BestUnit(energyRms,"Energy")<<"\n";

G4double polarizationMean=sumPolarization/totalNumber;

G4double polarizationRms=

std::sqrt(sumPolarization2/totalNumber-polarizationMean*polarizationMean);

G4cout<<"Mean Polarization :"<< polarizationMean

<<" +- "<<polarizationRms<<"\n";


void RunAction::ParticleStatistics::Clear()

currentNumber=0;

totalNumber=totalNumber2=0;

sumEnergy=sumEnergy2=0;

sumPolarization=sumPolarization2=0;

sumCosTheta=sumCosTheta2=0;


D.3 120

D.3.10. StepMax.cc

#include "StepMax.hh" #include "StepMaxMessenger.hh"


StepMax::StepMax(const G4String& processName)

: G4VDiscreteProcess(processName),MaxChargedStep(DBL_MAX)

pMess = new StepMaxMessenger(this);


StepMax::~StepMax() delete pMess;


G4bool StepMax::IsApplicable(const G4ParticleDefinition& particle)

return (particle.GetPDGCharge() != 0.);


void StepMax::SetMaxStep(G4double step) MaxChargedStep = step;


G4double StepMax::PostStepGetPhysicalInteractionLength(const

G4Track& aTrack,

G4double,

G4ForceCondition* condition )

// condition is set to "Not Forced"

*condition = NotForced;

G4double ProposedStep = DBL_MAX;

if((MaxChargedStep > 0.) &&

(aTrack.GetVolume() != 0) &&

(aTrack.GetVolume()->GetName() != "World"))

ProposedStep = MaxChargedStep;

D.3 121

return ProposedStep;


G4VParticleChange* StepMax::PostStepDoIt(const G4Track& aTrack,

const G4Step&)

// do nothing

aParticleChange.Initialize(aTrack);

return &aParticleChange;


D.3.11. StepMaxMessenger.cc

#include "StepMaxMessenger.hh"

#include "StepMax.hh" #include "G4UIcmdWithADoubleAndUnit.hh"


StepMaxMessenger::StepMaxMessenger(StepMax* stepM) :pStepMax(stepM)

StepMaxCmd = new G4UIcmdWithADoubleAndUnit("/testem/stepMax",this);

StepMaxCmd->SetGuidance("Set max allowed step length");

StepMaxCmd->SetParameterName("mxStep",false);

StepMaxCmd->SetRange("mxStep>0.");

StepMaxCmd->SetUnitCategory("Length");


StepMaxMessenger::~StepMaxMessenger()

delete StepMaxCmd;


void StepMaxMessenger::SetNewValue(G4UIcommand* command, G4String

newValue)

if (command == StepMaxCmd)

pStepMax->SetMaxStep(StepMaxCmd->GetNewDoubleValue(newValue));

D.3 122


D.3.12. SteppingAction.cc

#include "SteppingAction.hh" #include "DetectorConstruction.hh"

#include "PrimaryGeneratorAction.hh" #include "RunAction.hh"

#include "HistoManager.hh"

#include "G4RunManager.hh" #include "G4PolarizationHelper.hh"


SteppingAction::SteppingAction(DetectorConstruction* det,

PrimaryGeneratorAction* prim, RunAction* RuAct,

HistoManager* Hist)

:detector(det), primary(prim), runAction(RuAct), histoManager(Hist)


SteppingAction::~SteppingAction()


void SteppingAction::UserSteppingAction(const G4Step* aStep)

//G4StepPoint* prePoint = aStep->GetPreStepPoint();

G4StepPoint* endPoint = aStep->GetPostStepPoint();

G4String procName = endPoint->GetProcessDefinedStep()->GetProcessName();

runAction->CountProcesses(procName);

//if (prePoint->GetTouchableHandle()->GetVolume()==detector->GetBox() &&

// endPoint->GetTouchableHandle()->GetVolume()==detector->GetWorld())

// prePoint->GetTouchableHandle()->GetVolume()==detector->GetGasRPC() &&

if ( endPoint->GetTouchableHandle()->GetVolume()

==detector->GetCajaAire())

G4Track* aTrack = aStep->GetTrack();

D.4 123

G4String

particleName = aTrack->GetDynamicParticle()->

GetDefinition()->GetParticleName();

// G4cout<<"a "<<particleName<<" left the Box \n";

////cambiado y agregado por mi

G4ThreeVector position = endPoint->GetPosition();

G4double positionX = endPoint->GetPosition().x();

G4double positionY = endPoint->GetPosition().y();


G4ThreeVector direction = endPoint->GetMomentumDirection();

G4double kinEnergy = endPoint->GetKineticEnergy();

G4ThreeVector

beamDirection = primary->GetParticleGun()->GetParticleMomentumDirection();

G4double polZ = endPoint->GetPolarization().z();

G4double costheta=direction*beamDirection;

G4double

xdir=direction*G4PolarizationHelper::GetParticleFrameX(beamDirection);

G4double

ydir=direction*G4PolarizationHelper::GetParticleFrameY(beamDirection);

G4double phi=std::atan2(ydir,xdir);

////modificado por mi

histoManager->

FillHistos(particleName,kinEnergy,costheta,phi,polZ,positionX,positionY);


runAction->FillData(particleName,kinEnergy,costheta,phi,polZ);


D.4 124

D.4. Archivos contenidos en la carpeta include

D.4.1. DetectorConstruction.hh

#ifndef DetectorConstruction_H #define DetectorConstruction_H 1

#include "globals.hh" #include "G4VUserDetectorConstruction.hh"


#include "G4ios.hh"

class G4Box; class G4LogicalVolume; class G4VPhysicalVolume; class

G4Material; class DetectorMessenger;

//class ExN01ElectricFieldSetup;

class DetectorConstruction : public G4VUserDetectorConstruction

public:

DetectorConstruction();

~DetectorConstruction();

G4VPhysicalVolume* Construct();

//void SetMagField(G4double);

const G4VPhysicalVolume* GetWorld() return VolumenGeneral_phys;;

const G4VPhysicalVolume* GetCajaAire() return CorreccionAngulo_phys;;

private:

// Logical volumes

//

G4LogicalVolume* VolumenGeneral_log;

G4LogicalVolume* Aluminio_log;

G4LogicalVolume* CorreccionAngulo_log;

// Physical volumes

//

G4VPhysicalVolume* VolumenGeneral_phys;

G4VPhysicalVolume* Aluminio_phys;

G4VPhysicalVolume* CorreccionAngulo_phys;

D.4 125

//ExN01ElectricFieldSetup* fEmFieldSetup; // pointer to the field helper

//ExN01MagneticField* fpMagField; // pointer to the magnetic field

DetectorMessenger* detectorMessenger; // pointer to the Messenger

;

#endif

D.4.2. DetectorMessenger.hh

#ifndef DetectorMessenger_h #define DetectorMessenger_h 1

#include "G4UImessenger.hh" #include "globals.hh"

class DetectorConstruction; class G4UIdirectory; class

G4UIcmdWithAString; class G4UIcmdWithADoubleAndUnit; class

G4UIcmdWithoutParameter;


class DetectorMessenger: public G4UImessenger

public:

DetectorMessenger(DetectorConstruction* );

~DetectorMessenger();

void SetNewValue(G4UIcommand*, G4String);

private:

DetectorConstruction* Detector;

;


#endif

D.4 126

D.4.3. EventAction.hh

#ifndef EventAction_h #define EventAction_h 1

#include "G4UserEventAction.hh" #include "globals.hh"

class EventActionMessenger; class RunAction;


class EventAction : public G4UserEventAction

public:

EventAction(RunAction *);

~EventAction();

public:

void BeginOfEventAction(const G4Event*);

void EndOfEventAction(const G4Event*);

void SetPrintModulo(G4int val) printModulo = val;;

private:

G4int printModulo;

EventActionMessenger* eventMessenger;

RunAction* runAction;

;


#endif

D.4.4. EventActionMessenger.hh

#ifndef EventActionMessenger_h #define EventActionMessenger_h 1


class EventAction; class G4UIdirectory; class G4UIcmdWithAnInteger;


D.4 127

class EventActionMessenger: public G4UImessenger

public:

EventActionMessenger(EventAction*);

~EventActionMessenger();


private:

EventAction* eventAction;

G4UIdirectory* eventDir;

G4UIcmdWithAnInteger* PrintCmd;

;


#endif

D.4.5. HistoManager.hh

#ifndef HistoManager_h #define HistoManager_h 1



namespace AIDA

class IAnalysisFactory;

class ITree;

class IHistogram1D;

/////Mi agregado

class ICloud2D;

/////Mi agregado

class HistoMessenger;

const G4int MaxHisto = 13;


D.4 128

class HistoManager public:

HistoManager();

~HistoManager();

void SetFileName (const G4String& name) fileName[0] = name;;

void SetFileType (const G4String& name) fileType = name;;

void SetFileOption (const G4String& name) fileType = name;;

void book();

void save();

void SetHisto (G4int,G4int,G4double,G4double,const G4String& unit="none");

void FillHisto(G4int id, G4double e, G4double weight = 1.0);

void FillHistos(const G4String & particleName,

G4double kinEnergy, G4double costheta, G4double phi,


/////Mi agregado


/////Mi agregado

);

void RemoveHisto (G4int);

G4bool HistoExist (G4int id) return exist[id];

G4double GetHistoUnit(G4int id) return Unit[id];

G4double GetBinWidth (G4int id) return Width[id];

private:

G4String fileName[2];

G4String fileType;

G4String fileOption;

AIDA::IAnalysisFactory* af;

AIDA::ITree* tree;

AIDA::IHistogram1D* histo[MaxHisto];

/////Mi agregado

AIDA::ICloud2D* cloud;

/////Mi agregado

G4bool exist[MaxHisto];

G4String Label[MaxHisto];

G4String Title[MaxHisto];

G4int Nbins[MaxHisto];

G4double Vmin [MaxHisto];

D.4 129

G4double Vmax [MaxHisto];

G4double Unit [MaxHisto];

G4double Width[MaxHisto];

G4bool factoryOn;

HistoMessenger* histoMessenger;

;


#endif

D.4.6. HistoMessenger.hh

#ifndef HistoMessenger_h #define HistoMessenger_h 1



class HistoManager; class G4UIdirectory; class G4UIcommand; class

G4UIcmdWithAString; class G4UIcmdWithAnInteger;


class HistoMessenger: public G4UImessenger

public:

HistoMessenger(HistoManager* );

~HistoMessenger();

void SetNewValue(G4UIcommand* ,G4String );

private:

HistoManager* histoManager;

G4UIdirectory* histoDir;

G4UIcmdWithAString* factoryCmd;

G4UIcmdWithAString* typeCmd;

G4UIcmdWithAString* optionCmd;

G4UIcommand* histoCmd;

D.4 130

G4UIcmdWithAnInteger* rmhistoCmd;

;


#endif

D.4.7. PhysicsList.hh

#ifndef PhysicsList_h #define PhysicsList_h 1

#include "G4VUserPhysicsList.hh" #include "globals.hh"


class PhysicsList: public G4VUserPhysicsList

public:

PhysicsList();

~PhysicsList();

protected:

// Construct particle and physics

void ConstructParticle();

void ConstructProcess();

void SetCuts();

protected:

// these methods Construct particles

void ConstructBosons();

void ConstructLeptons();

void ConstructMesons();

void ConstructBaryons();

protected:

// these methods Construct physics processes and register them

void ConstructGeneral();

void ConstructEM();

D.4 131

;


#endif

D.4.8. PrimaryGeneratorAction.hh

#ifndef PrimaryGeneratorAction_h #define PrimaryGeneratorAction_h 1

#include "G4VUserPrimaryGeneratorAction.hh" #include

"G4ParticleGun.hh" #include "globals.hh"

//class G4ParticleGun;

class G4Event;

class PrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction

public:

PrimaryGeneratorAction();

~PrimaryGeneratorAction();

public:

void GeneratePrimaries(G4Event* anEvent);

G4ParticleGun* GetParticleGun() return particleGun;;

private:

G4ParticleGun* particleGun;

;

#endif

D.4.9. ProcessesCount.hh

#ifndef ProcessesCount_HH #define ProcessesCount_HH

#include "globals.hh" #include <vector>


D.4 132

class OneProcessCount public:

OneProcessCount(G4String name) Name=name; Counter=0;;

~OneProcessCount() ;

public:

G4String GetName() return Name;;

G4int GetCounter() return Counter;;

void Count() Counter++;;

private:

G4String Name; // process name

G4int Counter; // process counter

;


typedef std::vector<OneProcessCount*> ProcessesCount;

#endif

D.4.10. RunAction.hh

#ifndef RunAction_h #define RunAction_h 1

#include "G4UserRunAction.hh" #include "ProcessesCount.hh" #include

"globals.hh"


class DetectorConstruction; class PrimaryGeneratorAction; class

HistoManager; class G4Run;


class RunAction : public G4UserRunAction

class ParticleStatistics

public:

ParticleStatistics();

~ParticleStatistics();

void EventFinished();

void FillData(G4double kinEnergy, G4double costheta,

G4double longitudinalPolarization);

void PrintResults(G4int totalNumberOfEvents);

D.4 133

void Clear();

private:

G4int currentNumber;

G4int totalNumber, totalNumber2;

G4double sumEnergy, sumEnergy2;

G4double sumPolarization, sumPolarization2;

G4double sumCosTheta, sumCosTheta2;

;

public:

RunAction(DetectorConstruction*, PrimaryGeneratorAction*, HistoManager*);

virtual ~RunAction();

public:

void BeginOfRunAction(const G4Run*);

void EndOfRunAction(const G4Run*);

void CountProcesses(G4String);

void FillData(const G4String & particleName,




private:

DetectorConstruction* detector;

PrimaryGeneratorAction* primary;

ProcessesCount* ProcCounter;


G4int totalEventCount;

ParticleStatistics photonStats;

ParticleStatistics electronStats;

ParticleStatistics positronStats;

;


#endif

D.4 134

D.4.11. StepMax.hh

#ifndef StepMax_h #define StepMax_h 1

#include "globals.hh" #include "G4VDiscreteProcess.hh" #include

"G4ParticleDefinition.hh" #include "G4Step.hh"

class StepMaxMessenger;


class StepMax : public G4VDiscreteProcess

public:

StepMax(const G4String& processName ="stepMax");

~StepMax();

G4bool IsApplicable(const G4ParticleDefinition&);

void SetMaxStep(G4double);

G4double GetMaxStep() return MaxChargedStep;;

G4double PostStepGetPhysicalInteractionLength( const G4Track& track,

G4double previousStepSize,

G4ForceCondition* condition);

G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);

G4double GetMeanFreePath(const G4Track&, G4double, G4ForceCondition*)

return 0.;; // it is not needed here !

private:

G4double MaxChargedStep;

StepMaxMessenger* pMess;

;


#endif

D.4 135

D.4.12. StepMaxMessenger.hh

#ifndef StepMaxMessenger_h #define StepMaxMessenger_h 1


class StepMax; class G4UIcmdWithADoubleAndUnit;


class StepMaxMessenger: public G4UImessenger

public:

StepMaxMessenger(StepMax*);

~StepMaxMessenger();


private:

StepMax* pStepMax;

G4UIcmdWithADoubleAndUnit* StepMaxCmd;

;


#endif

D.4.13. SteppingAction.hh

#ifndef SteppingAction_h #define SteppingAction_h 1

#include "G4UserSteppingAction.hh" #include "globals.hh"


RunAction; class HistoManager;


class SteppingAction : public G4UserSteppingAction

public:

SteppingAction(DetectorConstruction*, PrimaryGeneratorAction*, RunAction*,

D.4 136

HistoManager*);

~SteppingAction();

void UserSteppingAction(const G4Step*);

private:





;


#endif

Apéndice E

Clases implementadas para lasimulación de una RPC

Aquí vamos a mostrar las clases implementadas para la simulación de la in-cidencia de muones de 1 GeV y gammas de 0.237 MeV sobre una cámara RPCcomo se explica en la sección "Simulación de una cámara RPC".

Cualquier aplicación de Geant4 debe de contener un directorio principal con 2directorios (include y src) y dos archivo, el ejecutable (GNUmakele) y el archivoprincipal.

La carpeta principal donde se encuentra todo la aplicación para simular la in-cidencia de la placa de aluminio se llama: "Simulacion RPC".

E.1. Archivo Principal: pol01.cc

#include "G4RunManager.hh" #include "G4UImanager.hh" #include

"G4UIterminal.hh" #include "G4UItcsh.hh" #include "Randomize.hh"

#include "DetectorConstruction.hh" #include "ElectricFieldSetup.hh"

#include "PhysicsList.hh" #include "PrimaryGeneratorAction.hh"

#include "RunAction.hh" #include "EventAction.hh" #include

"SteppingAction.hh" #include "HistoManager.hh"

#ifdef G4VIS_USE

#include "G4VisExecutive.hh"

#endif


E.1 138

int main(int argc,char** argv)

//choose the Random engine

// CLHEP::HepRandom::setTheEngine(new CLHEP::RanecuEngine);

// CLHEP::HepRandom::setTheEngine(new CLHEP::RanluxEngine());

// Construct the default run manager

G4RunManager * runManager = new G4RunManager;

ElectricFieldSetup* field = new ElectricFieldSetup() ;

// set mandatory initialization classes


det = new DetectorConstruction;

runManager->SetUserInitialization(det);

runManager->SetUserInitialization(new PhysicsList(det));

PrimaryGeneratorAction* prim;

/*


runManager->SetUserInitialization(det = new DetectorConstruction);

runManager->SetUserInitialization(new PhysicsList);

*/

runManager->SetUserAction(prim = new PrimaryGeneratorAction);

//runManager->SetUserAction(prim = new PrimaryGeneratorAction(det));

G4VisManager* visManager = 0;

HistoManager* histo = new HistoManager();

// set user action classes

RunAction* run;

runManager->SetUserAction(run = new RunAction(det,prim,histo));

runManager->SetUserAction(new EventAction(run));

runManager->SetUserAction(new SteppingAction(det,prim,run,histo));

// get the pointer to the User Interface manager

G4UImanager* UI = G4UImanager::GetUIpointer();

if (argc==1) // Define UI terminal for interactive mode

#ifdef G4VIS_USE

// visualization manager

E.2 139

visManager = new G4VisExecutive;

visManager->Initialize();

#endif

G4UIsession * session = 0;

#ifdef G4UI_USE_TCSH

session = new G4UIterminal(new G4UItcsh);

#else

session = new G4UIterminal();

#endif

session->SessionStart();

delete session;

else // Batch mode

G4String command = "/control/execute ";

G4String fileName = argv[1];

UI->ApplyCommand(command+fileName);

// job termination

if(visManager) delete visManager;

delete histo;

delete runManager;

delete field;

return 0;


E.2. Ejecutable: GNUmakele

name := pol01 G4TARGET := $(name) G4EXLIB := true

ifndef G4INSTALL

G4INSTALL = ../../../..

endif

.PHONY: all all: lib bin

include $(G4INSTALL)/config/binmake.gmk

E.3 140

ifdef G4ANALYSIS_USE

# for the aida-config command see the README file

CPPFLAGS += `aida-config --include`

LDLIBS += `aida-config --lib`

plots: plotResults.class

@echo calling JAIDA ...

java -cp .:$(CLASSPATH) plotResults pol01.aida

plotResults.class: plotResults.java

@echo compiling $<

javac $<

endif

E.3. Archivos contenidos en la carpeta src

E.3.1. DetectorConstruction.cc

#include "DetectorConstruction.hh" #include "DetectorMessenger.hh"


#include "ElectricFieldSetup.hh"

#include "G4Material.hh" #include "G4Box.hh" #include "G4Tubs.hh"

#include "G4LogicalVolume.hh" #include "G4ThreeVector.hh" #include

"G4PVPlacement.hh" #include "globals.hh"

#include "G4NistManager.hh"

#include "G4FieldManager.hh" #include "G4UniformMagField.hh"

#include "G4TransportationManager.hh"

#include "G4RunManager.hh"

#include "G4PVParameterised.hh" #include "G4SDManager.hh" #include

"G4GeometryTolerance.hh" #include "G4GeometryManager.hh"

#include "G4UserLimits.hh"

E.3 141

#include "G4VisAttributes.hh" #include "G4Colour.hh"

#include "G4ios.hh"

DetectorConstruction::DetectorConstruction()

: VolumenGeneral_log(0), Baquelita_log(0),

Grafito_log(0), Polietileno_log(0), GasC2H2F4_log(0), Aluminio_log(0),

VolumenGeneral_phys(0), Baquelita_phys(0),

Grafito_phys(0), Polietileno_phys(0),

GasC2H2F4_phys(0), Aluminio_phys(0), fEmFieldSetup(0)

// fpMagField(0)

// fpMagField = new ExN01MagneticField();

detectorMessenger = new DetectorMessenger(this);

fEmFieldSetup = new ElectricFieldSetup() ;

DetectorConstruction::~DetectorConstruction()

//delete fpMagField;

delete detectorMessenger;

delete fEmFieldSetup ;

G4VPhysicalVolume* DetectorConstruction::Construct()

//------------------------------------------------------ materials

G4String symbol; G4double a, z, density; //z=mean number of

protons;

//iz=number of protons in an isotope;

// n=number of nucleons in an isotope;

G4int ncomponents, natoms;

G4Element* H = new G4Element("Hydrogen",symbol="H" , z= 1., a=

1.01*g/mole); G4Element* C = new G4Element("Carbon" ,symbol="C" ,

E.3 142

z= 6., a= 12.01*g/mole);

//G4Element* N = new G4Element("Nitrogen",symbol="N" , z= 7., a= 14.01*g/mole);

//G4Element* O = new G4Element("Oxygen" ,symbol="O" , z= 8., a= 16.00*g/mole);

G4Element* F = new G4Element("Fluor",symbol="F" , z= 9., a=

19.00*g/mole);

G4Material* C2H2F4 = new G4Material("GasEnRpc", density=

4089.26*g/m3, ncomponents=3, kStateGas, 300.*kelvin, 1.*bar);

C2H2F4->AddElement(C, natoms=2); C2H2F4->AddElement(H, natoms=2);

C2H2F4->AddElement(F, natoms=4);

G4Material* Al = new G4Material("Aluminum", z= 13., a= 26.98*g/mole,

density= 2.7*g/cm3);

G4NistManager* man = G4NistManager::Instance();

G4Material* MAir = man->FindOrBuildMaterial("G4_AIR"); G4Material*

MBak = man->FindOrBuildMaterial("G4_BAKELITE"); G4Material* MGraf =

man->FindOrBuildMaterial("G4_GRAPHITE"); G4Material* MPoli =

man->FindOrBuildMaterial("G4_POLYETHYLENE");

//------------------------------------------------------Volumenes

//------------------------------ Volumen general lleno de Aire

G4double VolGen_x = 15.5*cm;

G4double VolGen_y = 15.5*cm;

G4double VolGen_z = 8.0*mm;

G4Box* VolumenGeneral_box

= new G4Box("VolGen_box",VolGen_x,VolGen_y,VolGen_z);

VolumenGeneral_log = new G4LogicalVolume(VolumenGeneral_box,

MAir,"VolGen_log",0,0,0);

VolumenGeneral_phys = new G4PVPlacement(0,G4ThreeVector(),

VolumenGeneral_log,"VolGen",0,false,0);

//------------------------------ Capas de Baquelita

E.3 143

G4double baque_x = 15.0*cm;

G4double baque_y = 15.0*cm;

G4double baque_z = 1.0*mm;

G4Box* Baquelita_box = new G4Box("Baque_box",baque_x,

baque_y,baque_z);

Baquelita_log = new G4LogicalVolume(Baquelita_box,

MBak,"Baque_log",0,0,0);



G4double baquePos1_z = 2.0*mm;






G4double baquePos2_z = -2.0*mm;




//------------------------------ Capas de Grafito

G4double grafi_x = 15.0*cm;

G4double grafi_y = 15.0*cm;

G4double grafi_z = 0.1*mm;

G4Box* Grafito_box = new G4Box("Grafi_box",grafi_x,

grafi_y,grafi_z);

Grafito_log = new G4LogicalVolume(Grafito_box,

MGraf,"Grafi_log",0,0,0);



G4double grafiPos1_z = 3.1*mm;






G4double grafiPos2_z = -3.1*mm;




E.3 144

//------------------------------ Capas de Polietileno

G4double poli_x = 15.0*cm;

G4double poli_y = 15.0*cm;

G4double poli_z = 0.1*mm;

G4Box* Polietileno_box = new G4Box("Poli_box",poli_x,

poli_y,poli_z);

Polietileno_log = new G4LogicalVolume(Polietileno_box,

MPoli,"Poli_log",0,0,0);



G4double PoliPos1_z = 3.3*mm;






G4double PoliPos2_z = -3.3*mm;




//------------------------------ Gas dentro de la camara

G4double gas_x = 15.0*cm;

G4double gas_y = 15.0*cm;

G4double gas_z = 1.0*mm;

G4Box* GasC2H2F4_box = new G4Box("Gas_box",gas_x,

gas_y,gas_z);

GasC2H2F4_log = new G4LogicalVolume(GasC2H2F4_box,

C2H2F4,"Gas_log",0,0,0);

G4double GasPos_x = 0.0*mm;

G4double GasPos_y = 0.0*mm;

G4double GasPos_z = 0.0*mm;

GasC2H2F4_phys = new G4PVPlacement(0,

G4ThreeVector(GasPos_x,GasPos_y,GasPos_z),

GasC2H2F4_log,"Gas",VolumenGeneral_log,false,0);

//------------------------------ Capa de Aluminio

G4double alu_x = 15.0*cm;

G4double alu_y = 15.0*cm;

E.3 145

G4double alu_z = 0.02*mm;

G4Box* Aluminio_box = new G4Box("Alu_box",alu_x,

alu_y,alu_z);

Aluminio_log = new G4LogicalVolume(Aluminio_box,

Al,"Alu_log",0,0,0);

G4double AluPos_x = 0.0*mm;

G4double AluPos_y = 0.0*mm;

G4double AluPos_z = -3.42*mm;

Aluminio_phys = new G4PVPlacement(0,

G4ThreeVector(AluPos_x,AluPos_y,AluPos_z),

Aluminio_log,"Aluminio",VolumenGeneral_log,false,0);

/*

G4Region* aRegion = new G4Region("Baque_log");

Baquelita_log ->SetRegion(aRegion);

aRegion->AddRootLogicalVolume( Baquelita_log);

G4Region* aRegion1 = new G4Region("Poli_log");

Polietileno_log ->SetRegion(aRegion1);

aRegion1->AddRootLogicalVolume( Polietileno_log);

G4Region* aRegion2 = new G4Region("Grafi_log");

Grafito_log->SetRegion(aRegion2);

aRegion2->AddRootLogicalVolume( Grafito_log);

*/

G4Region* aRegion3 = new G4Region("Gas_log");

GasC2H2F4_log ->SetRegion(aRegion3);

aRegion3->AddRootLogicalVolume( GasC2H2F4_log);

/* G4Region* aRegion4 = new G4Region("Alu_log");

Aluminio_log ->SetRegion(aRegion4);

aRegion4->AddRootLogicalVolume( Aluminio_log);

*/



Grafito_log->SetVisAttributes(atb);

E.3 146



Baquelita_log->SetVisAttributes(atb);



Aluminio_log->SetVisAttributes(atb);



Polietileno_log->SetVisAttributes(atb);

return VolumenGeneral_phys;

E.3.2. DetectorMessenger.cc


#include "DetectorConstruction.hh" #include "G4UIdirectory.hh"

#include "G4UIcmdWithAString.hh" #include

"G4UIcmdWithADoubleAndUnit.hh" #include "G4UIcmdWithoutParameter.hh"


DetectorMessenger::DetectorMessenger(DetectorConstruction * Det)

:Detector(Det)


DetectorMessenger::~DetectorMessenger()


void DetectorMessenger::SetNewValue(G4UIcommand*, G4String)


E.3 147

E.3.3. ElectricFieldSetup.cc

#include "ElectricFieldSetup.hh" #include "FieldMessenger.hh"

#include "G4UniformElectricField.hh" #include "G4UniformMagField.hh"

#include "G4MagneticField.hh" #include "G4FieldManager.hh" #include

"G4TransportationManager.hh" #include "G4EquationOfMotion.hh"

#include "G4EqMagElectricField.hh" #include "G4Mag_UsualEqRhs.hh"

#include "G4MagIntegratorStepper.hh" #include

"G4MagIntegratorDriver.hh" #include "G4ChordFinder.hh"

#include "G4ExplicitEuler.hh" #include "G4ImplicitEuler.hh" #include

"G4SimpleRunge.hh" #include "G4SimpleHeum.hh" #include

"G4ClassicalRK4.hh" #include "G4HelixExplicitEuler.hh" #include

"G4HelixImplicitEuler.hh" #include "G4HelixSimpleRunge.hh" #include

"G4CashKarpRKF45.hh" #include "G4RKG3_Stepper.hh"

//////////////////////////////////////////////////////////////////////////

//

// Constructors:

ElectricFieldSetup::ElectricFieldSetup()

: fChordFinder(0), fStepper(0), fIntgrDriver(0)

fEMfield = new G4UniformElectricField(

G4ThreeVector(0.0,0.0,-4.5*kilovolt/mm));

fFieldMessenger = new FieldMessenger(this) ;

fEquation = new G4EqMagElectricField(fEMfield);

fMinStep = 0.01*mm ; // minimal step of 0.1mm

fStepperType = 4 ; // ClassicalRK4 -- the default stepper

fFieldManager = GetGlobalFieldManager();

UpdateField();

////////////////////////////////////////////////////////////////////////////

ElectricFieldSetup::ElectricFieldSetup(G4ThreeVector pFV)

: fChordFinder(0),

fStepper(0),

fIntgrDriver(0)

E.3 148

fEMfield = new G4UniformElectricField(pFV);

// GetGlobalFieldManager()->CreateChordFinder(this);

fFieldMessenger = new FieldMessenger(this) ;

fEquation = new G4EqMagElectricField(fEMfield);

fMinStep = 0.01*mm ; // minimal step of 10 microns

fStepperType = 4 ; // ClassicalRK4 -- the default stepper

fFieldManager = GetGlobalFieldManager();

UpdateField();

/////////////////////////////////////////////////////////////////////////////

ElectricFieldSetup::~ElectricFieldSetup()

if(fChordFinder) delete fChordFinder;

if(fStepper) delete fStepper;

if(fEquation) delete fEquation;

if(fEMfield) delete fEMfield;

/////////////////////////////////////////////////////////////////////////////

//

// Register this field to 'global' Field Manager and

// Create Stepper and Chord Finder with predefined type, minstep (resp.)

//

void ElectricFieldSetup::UpdateField()

SetStepper();

G4cout<<"The minimal step is equal to "<<fMinStep/mm<<" mm"<<G4endl ;

fFieldManager->SetDetectorField(fEMfield );

if(fChordFinder) delete fChordFinder;

// fChordFinder = new G4ChordFinder( fEMfield, fMinStep, fStepper);

fIntgrDriver = new G4MagInt_Driver(fMinStep,

fStepper,

fStepper->GetNumberOfVariables() );

fChordFinder = new G4ChordFinder(fIntgrDriver);

E.3 149

fFieldManager->SetChordFinder( fChordFinder );

/////////////////////////////////////////////////////////////////////////////

//

// Set stepper according to the stepper type

//

void ElectricFieldSetup::SetStepper()

G4int nvar = 8;

if(fStepper) delete fStepper;

switch ( fStepperType )

case 0:

fStepper = new G4ExplicitEuler( fEquation, nvar );

G4cout<<"G4ExplicitEuler is calledS"<<G4endl;

break;

case 1:

fStepper = new G4ImplicitEuler( fEquation, nvar );

G4cout<<"G4ImplicitEuler is called"<<G4endl;

break;

case 2:

fStepper = new G4SimpleRunge( fEquation, nvar );

G4cout<<"G4SimpleRunge is called"<<G4endl;

break;

case 3:

fStepper = new G4SimpleHeum( fEquation, nvar );

G4cout<<"G4SimpleHeum is called"<<G4endl;

break;

case 4:

fStepper = new G4ClassicalRK4( fEquation, nvar );

G4cout<<"G4ClassicalRK4 (default) is called"<<G4endl;

break;

case 5:

fStepper = new G4CashKarpRKF45( fEquation, nvar );

G4cout<<"G4CashKarpRKF45 is called"<<G4endl;

break;

case 6:

fStepper = 0; // new G4RKG3_Stepper( fEquation, nvar );

G4cout<<"G4RKG3_Stepper is not currently working

for Electric Field"<<G4endl;

break;

E.3 150

case 7:

fStepper = 0; // new G4HelixExplicitEuler( fEquation );

G4cout<<"G4HelixExplicitEuler is not valid for Electric Field"<<G4endl;

break;

case 8:

fStepper = 0; // new G4HelixImplicitEuler( fEquation );

G4cout<<"G4HelixImplicitEuler is not valid for Electric Field"<<G4endl;

break;

case 9:

fStepper = 0; // new G4HelixSimpleRunge( fEquation );

G4cout<<"G4HelixSimpleRunge is not valid for Electric Field"<<G4endl;

break;

default: fStepper = 0;

/////////////////////////////////////////////////////////////////////////////

//

// Set the value of the Global Field to fieldValue along Z

//

void ElectricFieldSetup::SetFieldValue(G4double fieldValue)

G4ThreeVector fieldVector( 0.0, 0.0, 0.0 /*fieldValue*/ );

SetFieldValue( fieldVector );

///////////////////////////////////////////////////////////////////////////////

//

// Set the value of the Global Field value to fieldVector

//

void ElectricFieldSetup::SetFieldValue(G4ThreeVector fieldVector)

// Find the Field Manager for the global field

G4FieldManager* fieldMgr= GetGlobalFieldManager();

if(fieldVector != G4ThreeVector(0.,0.,0.))


fEMfield = new G4UniformElectricField(fieldVector);

fEquation->SetFieldObj(fEMfield); // must now point to the new field

// UpdateField();

E.3 151

fieldMgr->SetDetectorField(fEMfield);

else

// If the new field's value is Zero, then it is best to

// insure that it is not used for propagation.


fEMfield = 0;

fEquation->SetFieldObj(fEMfield); // As a double check ...

G4MagneticField* fEMfield = 0;

fieldMgr->SetDetectorField(fEMfield);

////////////////////////////////////////////////////////////////////////////////

//

// Utility method

G4FieldManager* ElectricFieldSetup::GetGlobalFieldManager()

return G4TransportationManager::GetTransportationManager()

->GetFieldManager();

E.3.4. EventAction.cc



#include "G4Event.hh" #include "G4TrajectoryContainer.hh" #include

"G4Trajectory.hh" #include "G4VVisManager.hh" #include

"G4UnitsTable.hh" #include "RunAction.hh"


EventAction::EventAction(RunAction * ra)

:printModulo(10000),eventMessenger(0),runAction(ra)

eventMessenger = new EventActionMessenger(this);


E.3 152

EventAction::~EventAction()

delete eventMessenger;


void EventAction::BeginOfEventAction(const G4Event* evt)

G4int evtNb = evt->GetEventID();

//printing survey

if (evtNb%printModulo == 0)

G4cout << "\n---> Begin of Event: " << evtNb << G4endl;


void EventAction::EndOfEventAction(const G4Event* evt)

if (runAction) runAction->EventFinished();

if (G4VVisManager::GetConcreteInstance())

G4TrajectoryContainer* trajectoryContainer = evt->GetTrajectoryContainer();

G4int n_trajectories = 0;

if (trajectoryContainer) n_trajectories = trajectoryContainer->entries();

for (G4int i=0; i<n_trajectories; i++)

G4Trajectory* trj = (G4Trajectory*)

((*(evt->GetTrajectoryContainer()))[i]);

trj->DrawTrajectory(1000);


E.3.5. EventActionMessenger.cc



#include "G4UIdirectory.hh" #include "G4UIcmdWithAnInteger.hh"

E.3 153


EventActionMessenger::EventActionMessenger(EventAction* EvAct)

:eventAction(EvAct)

eventDir = new G4UIdirectory("/testem/event/");

eventDir ->SetGuidance("event control");

PrintCmd = new G4UIcmdWithAnInteger("/testem/event/printModulo",this);

PrintCmd->SetGuidance("Print events modulo n");

PrintCmd->SetParameterName("EventNb",false);

PrintCmd->SetRange("EventNb>0");

PrintCmd->AvailableForStates(G4State_PreInit,G4State_Idle);


EventActionMessenger::~EventActionMessenger()

delete PrintCmd;

delete eventDir;


void EventActionMessenger::SetNewValue(G4UIcommand* command,

G4String newValue)

if (command == PrintCmd)

eventAction->SetPrintModulo(PrintCmd->GetNewIntValue(newValue));


E.3.6. FieldMessenger.cc

#include "FieldMessenger.hh"

#include "ElectricFieldSetup.hh" #include "G4UIdirectory.hh"

#include "G4UIcmdWithAString.hh" #include "G4UIcmdWithAnInteger.hh"

#include "G4UIcmdWithADoubleAndUnit.hh" #include

"G4UIcmdWithoutParameter.hh"

//////////////////////////////////////////////////////////////////////////////

E.3 154

FieldMessenger::FieldMessenger(ElectricFieldSetup* pEMfield)

:fEFieldSetup(pEMfield)

detDir = new G4UIdirectory("/field/");

detDir->SetGuidance(" field tracking control.");

StepperCmd = new G4UIcmdWithAnInteger("/field/setStepperType",this);

StepperCmd->SetGuidance("Select stepper type for electric field");

StepperCmd->SetParameterName("choice",true);

StepperCmd->SetDefaultValue(4);

StepperCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

UpdateCmd = new G4UIcmdWithoutParameter("/field/update",this);

UpdateCmd->SetGuidance("Update calorimeter geometry.");

UpdateCmd->SetGuidance("This command MUST be applied before \"beamOn\" ");

UpdateCmd->SetGuidance("if you changed geometrical value(s).");

UpdateCmd->AvailableForStates(G4State_Idle);

MagFieldCmd = new G4UIcmdWithADoubleAndUnit("/field/setFieldZ",this);

MagFieldCmd->SetGuidance("Define magnetic field.");

MagFieldCmd->SetGuidance("Magnetic field will be in Z direction.");

MagFieldCmd->SetParameterName("Bz",false,false);

MagFieldCmd->SetDefaultUnit("tesla");

MagFieldCmd->AvailableForStates(G4State_Idle);

MinStepCmd = new G4UIcmdWithADoubleAndUnit("/field/setMinStep",this);

MinStepCmd->SetGuidance("Define minimal step");

MinStepCmd->SetGuidance("Magnetic field will be in Z direction.");

MinStepCmd->SetParameterName("min step",false,false);

MinStepCmd->SetDefaultUnit("mm");

MinStepCmd->AvailableForStates(G4State_Idle);

AbsMaterCmd = new G4UIcmdWithAString("/field/setAbsMat",this);

AbsMaterCmd->SetGuidance("Select Material of the Absorber.");

AbsMaterCmd->SetParameterName("choice",true);

AbsMaterCmd->SetDefaultValue("Xe");

AbsMaterCmd->AvailableForStates(G4State_Idle);

///////////////////////////////////////////////////////////////////////////////

E.3 155

FieldMessenger::~FieldMessenger()

delete StepperCmd;

delete MagFieldCmd;

delete MinStepCmd;

delete detDir;

delete UpdateCmd;

delete AbsMaterCmd;

////////////////////////////////////////////////////////////////////////////

//

//

void FieldMessenger::SetNewValue( G4UIcommand* command, G4String

newValue)

if( command == StepperCmd )

fEFieldSetup->SetStepperType(StepperCmd->GetNewIntValue(newValue));

if( command == UpdateCmd )

fEFieldSetup->UpdateField();

if( command == MagFieldCmd )

fEFieldSetup->SetFieldValue(MagFieldCmd->GetNewDoubleValue(newValue));

if( command == MinStepCmd )

fEFieldSetup->SetMinStep(MinStepCmd->GetNewDoubleValue(newValue));

//

//

/////////////////////////////////////////////////////////////////////////

E.3.7. HistoManager.cc

#include "HistoManager.hh" #include "HistoMessenger.hh" #include

"G4UnitsTable.hh"

E.3 156

#ifdef G4ANALYSIS_USE #include "AIDA/AIDA.h" #endif


HistoManager::HistoManager() :af(0),tree(0),factoryOn(false)


// Creating the analysis factory

af = AIDA_createAnalysisFactory();

if(!af)

G4cout << " HistoManager::HistoManager() :"

<< " problem creating the AIDA analysis factory."

<< G4endl;

#endif

fileName[0] = "pol01.aida";

fileType = "xml";

fileOption = "compress=yes";

// histograms


histo[k] = 0;

exist[k] = false;

Unit[k] = 1.0;

Width[k] = 1.0;


cloud=0;


histoMessenger = new HistoMessenger(this);


HistoManager::~HistoManager()

delete histoMessenger;


delete af;

#endif

E.3 157


void HistoManager::book() #ifdef G4ANALYSIS_USE

if(!af) return;

// Creating a tree mapped to an aida file.

if (fileName[0].find(".")==G4String::npos)

fileName[1] = fileName[0] + "." + fileType;

else

fileName[1] = fileName[0];

G4bool readOnly = false;

G4bool createNew = true;

AIDA::ITreeFactory* tf = af->createTreeFactory();

tree = tf->create(fileName[1], fileType, readOnly, createNew, fileOption);

delete tf;

if(!tree)

G4cout << "HistoManager::book() :"

<< " problem creating the AIDA tree with "

<< " storeName = " << fileName[1]

<< " storeType = " << fileType

<< " readOnly = " << readOnly

<< " createNew = " << createNew

<< " options = " << fileOption

<< G4endl;

return;

// Creating a histogram factory, whose histograms will be handled by the tree

AIDA::IHistogramFactory* hf = af->createHistogramFactory(*tree);

// create selected histograms


if (exist[k])

histo[k] = hf->createHistogram1D( Label[k], Title[k],

Nbins[k], Vmin[k], Vmax[k]);

factoryOn = true;


cloud=hf->createCloud2D( "Scatter Plot X vs Y");


E.3 158

delete hf;

if(factoryOn)

G4cout << "\n----> Histogram Tree is opened " << fileName[1] << G4endl;

#endif


void HistoManager::save() #ifdef G4ANALYSIS_USE

if (factoryOn)

tree->commit(); // Writing the histograms to the file

tree->close(); // and closing the tree (and the file)

G4cout << "\n----> Histogram Tree is saved in " << fileName[1] << G4endl;

delete tree;

tree = 0;

factoryOn = false;

#endif


void HistoManager::FillHistos(const G4String & particleName,


G4double phi,


////mi agregado


////mi agregado

)

G4int id=1;

if (particleName=="gamma") id=1;


id=5;


cloud->fill(posX, posY);


else if (particleName=="e+") id=9;

else return;

if (costheta>=1.) costheta=.99999999;

if (costheta<-1.) costheta=-1.;

E.3 159

FillHisto(id,kinEnergy);

FillHisto(id+1,costheta);

FillHisto(id+2,phi);

FillHisto(id+3,longitudinalPolarization);

void HistoManager::FillHisto(G4int ih, G4double e, G4double weight)

if (ih > MaxHisto)

G4cout << "---> warning from HistoManager::FillHisto() : histo " << ih

<< "does not exist; e= " << e << " w= " << weight << G4endl;

return;


if(exist[ih]) histo[ih]->fill(e/Unit[ih], weight);

#endif


void HistoManager::SetHisto(G4int ih, G4int nbins, G4double valmin,

G4double valmax, const G4String& unit)

if (ih > MaxHisto)

G4cout << "---> warning from HistoManager::SetHisto() : histo " << ih


return;

const G4String id[] = "0", "1", "2", "3", "4", "5",

"6", "7", "8", "9", "10", "11", "12";

const G4String title[] =

"dummy", //0

"Gamma Energy distribution", //1

"Gamma Cos(Theta) distribution", //2

"Gamma Phi angular distribution", //3

"Gamma longitudinal Polarization", //4

"Electron Energy distribution", //5

"Electron Cos(Theta) distribution", //6

"Electron Phi angular distribution", //7

"Electron longitudinal Polarization", //8

"Positron Energy distribution", //9

E.3 160

"Positron Cos(Theta) distribution", //10

"Positron Phi angular distribution", //11

"Positron longitudinal Polarization" //12

;

G4String titl = title[ih];

G4double vmin = valmin, vmax = valmax;

Unit[ih] = 1.;

if (unit != "none")

titl = title[ih] + " (" + unit + ")";

Unit[ih] = G4UnitDefinition::GetValueOf(unit);

vmin = valmin/Unit[ih]; vmax = valmax/Unit[ih];

exist[ih] = true;

Label[ih] = id[ih];

Title[ih] = titl;

Nbins[ih] = nbins;

Vmin[ih] = vmin;

Vmax[ih] = vmax;

Width[ih] = (valmax-valmin)/nbins;

G4cout << "----> SetHisto " << ih << ": " << titl << "; "

<< nbins << " bins from "

<< vmin << " " << unit << " to " << vmax << " " << unit << G4endl;


void HistoManager::RemoveHisto(G4int ih)

if (ih > MaxHisto)

G4cout << "---> warning from HistoManager::RemoveHisto() : histo " << ih


return;

histo[ih] = 0; exist[ih] = false;


E.3 161

E.3.8. HistoMessenger.cc

#include "HistoMessenger.hh"

#include <sstream>

#include "HistoManager.hh" #include "G4UIdirectory.hh" #include

"G4UIcommand.hh" #include "G4UIparameter.hh" #include

"G4UIcmdWithAString.hh" #include "G4UIcmdWithAnInteger.hh"


HistoMessenger::HistoMessenger(HistoManager* manager) :histoManager

(manager)

histoDir = new G4UIdirectory("/testem/histo/");

histoDir->SetGuidance("histograms control");

factoryCmd = new G4UIcmdWithAString("/testem/histo/setFileName",this);

factoryCmd->SetGuidance("set name for the histograms file");

typeCmd = new G4UIcmdWithAString("/testem/histo/setFileType",this);

typeCmd->SetGuidance("set histograms file type");

typeCmd->SetCandidates("hbook root XML xml aida");

optionCmd = new G4UIcmdWithAString("/testem/histo/setFileOption",this);

optionCmd->SetGuidance("set option for the histograms file");

histoCmd = new G4UIcommand("/testem/histo/setHisto",this);

histoCmd->SetGuidance("Set bining of the histo number ih :");

histoCmd->SetGuidance(" nbBins; valMin; valMax; unit (of vmin and vmax)");

//

G4UIparameter* ih = new G4UIparameter("ih",'i',false);

ih->SetGuidance("histo number : from 1 to MaxHisto");

ih->SetParameterRange("ih>0");

histoCmd->SetParameter(ih);

//

G4UIparameter* nbBins = new G4UIparameter("nbBins",'i',false);

nbBins->SetGuidance("number of bins");

nbBins->SetParameterRange("nbBins>0");

histoCmd->SetParameter(nbBins);

//

G4UIparameter* valMin = new G4UIparameter("valMin",'d',false);

E.3 162

valMin->SetGuidance("valMin, expressed in unit");

histoCmd->SetParameter(valMin);

//

G4UIparameter* valMax = new G4UIparameter("valMax",'d',false);

valMax->SetGuidance("valMax, expressed in unit");

histoCmd->SetParameter(valMax);

//

G4UIparameter* unit = new G4UIparameter("unit",'s',true);

unit->SetGuidance("if omitted, vmin and vmax are assumed dimensionless");

unit->SetDefaultValue("none");

histoCmd->SetParameter(unit);

rmhistoCmd = new G4UIcmdWithAnInteger("/testem/histo/removeHisto",this);

rmhistoCmd->SetGuidance("desactivate histo #id");

rmhistoCmd->SetParameterName("id",false);

rmhistoCmd->SetRange("id>0");


HistoMessenger::~HistoMessenger()

delete rmhistoCmd;

delete histoCmd;

delete optionCmd;

delete typeCmd;

delete factoryCmd;

delete histoDir;


void HistoMessenger::SetNewValue(G4UIcommand* command, G4String

newValues)

if (command == factoryCmd)

histoManager->SetFileName(newValues);

if (command == typeCmd)

histoManager->SetFileType(newValues);

if (command == optionCmd)

histoManager->SetFileOption(newValues);

if (command == histoCmd)

G4int ih,nbBins; G4double vmin,vmax; char unts[30];

E.3 163

std::istringstream is(newValues.c_str());

is >> ih >> nbBins >> vmin >> vmax >> unts;

G4String unit = unts;

G4double vUnit = 1. ;

if (unit != "none") vUnit = G4UIcommand::ValueOf(unit);

histoManager->SetHisto (ih,nbBins,vmin*vUnit,vmax*vUnit,unit);

if (command == rmhistoCmd)

histoManager->RemoveHisto(rmhistoCmd->GetNewIntValue(newValues));


E.3.9. PhysicsList.cc

#include "globals.hh" #include "PhysicsList.hh"

#include "G4Timer.hh" #include "G4ProcessManager.hh" #include

"G4ParticleTypes.hh"

#include "G4ParticleDefinition.hh" #include "G4ParticleWithCuts.hh"

#include "G4ProcessManager.hh" #include "G4ProcessVector.hh"

#include "G4ParticleTypes.hh" #include "G4ParticleTable.hh" #include

"G4Material.hh" #include "G4EnergyLossTables.hh" #include

"G4UnitsTable.hh" #include "G4ios.hh" #include <iomanip>


PhysicsList::PhysicsList(DetectorConstruction* p) :

G4VUserPhysicsList(), MaxChargedStep(DBL_MAX),

thePhotoElectricEffect(0), theComptonScattering(0), theGammaConversion(0),

theeminusMultipleScattering(0), theeminusIonisation(0),

theeminusBremsstrahlung(0),

theeplusMultipleScattering(0), theeplusIonisation(0),

theeplusBremsstrahlung(0), theeplusAnnihilation(0),

theeminusStepCut(0), theeplusStepCut(0)

//PhysicsList::PhysicsList(): G4VUserPhysicsList()

pDet = p;

E.3 164

defaultCutValue = 1000.*m ;

cutForGamma = defaultCutValue ;

cutForElectron = defaultCutValue ;

SetVerboseLevel(1);

//defaultCutValue = 1.*m; ////esta en 0.1mm cambiando

////se arregla el uso del campo electrico

// SetVerboseLevel(1);


PhysicsList::~PhysicsList()


void PhysicsList::ConstructParticle()

// In this method, static member functions should be called

// for all particles which you want to use.

// This ensures that objects of these particle types will be

// created in the program.

ConstructBosons();

ConstructLeptons();

ConstructMesons();

ConstructBarions();


void PhysicsList::ConstructBosons()

// pseudo-particles

G4Geantino::GeantinoDefinition();

G4ChargedGeantino::ChargedGeantinoDefinition();

// gamma

G4Gamma::GammaDefinition();


void PhysicsList::ConstructLeptons()

E.3 165

// leptons

// e+/-

G4Electron::ElectronDefinition();

G4Positron::PositronDefinition();

// mu+/-

G4MuonPlus::MuonPlusDefinition();

G4MuonMinus::MuonMinusDefinition();

// nu_e

G4NeutrinoE::NeutrinoEDefinition();

G4AntiNeutrinoE::AntiNeutrinoEDefinition();

// nu_mu

G4NeutrinoMu::NeutrinoMuDefinition();

G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();


void PhysicsList::ConstructMesons()

// mesons

// light mesons

G4PionPlus::PionPlusDefinition();

G4PionMinus::PionMinusDefinition();

G4PionZero::PionZeroDefinition();

G4Eta::EtaDefinition();

G4EtaPrime::EtaPrimeDefinition();

G4KaonPlus::KaonPlusDefinition();

G4KaonMinus::KaonMinusDefinition();

G4KaonZero::KaonZeroDefinition();

G4AntiKaonZero::AntiKaonZeroDefinition();

G4KaonZeroLong::KaonZeroLongDefinition();

G4KaonZeroShort::KaonZeroShortDefinition();


void PhysicsList::ConstructBarions()

// barions

G4Proton::ProtonDefinition();

G4AntiProton::AntiProtonDefinition();

G4Neutron::NeutronDefinition();

G4AntiNeutron::AntiNeutronDefinition();

E.3 166


void PhysicsList::ConstructProcess()

AddTransportation();

ConstructEM();

ConstructGeneral();


#include "G4ComptonScattering.hh" #include "G4GammaConversion.hh"

#include "G4PhotoElectricEffect.hh"

#include "G4MultipleScattering.hh"

#include "G4eIonisation.hh" #include "G4eBremsstrahlung.hh" #include

"G4eplusAnnihilation.hh"

#include "G4MuIonisation.hh" #include "G4MuBremsstrahlung.hh"

#include "G4MuPairProduction.hh"

#include "G4hIonisation.hh"

#include "G4StepLimiter.hh" #include "G4UserSpecialCuts.hh"

#include "StepCut.hh"









// Construct processes for gamma

thePhotoElectricEffect = new G4PhotoElectricEffect();

E.3 167

theComptonScattering = new G4ComptonScattering();

theGammaConversion = new G4GammaConversion();

pmanager->AddDiscreteProcess(thePhotoElectricEffect);

pmanager->AddDiscreteProcess(theComptonScattering);

pmanager->AddDiscreteProcess(theGammaConversion);


// Construct processes for electron

theeminusIonisation = new G4eIonisation();

theeminusBremsstrahlung = new G4eBremsstrahlung();

theeminusStepCut = new StepCut();

pmanager->AddProcess(theeminusIonisation,-1,2,2);

pmanager->AddProcess(theeminusBremsstrahlung,-1,-1,3);

pmanager->AddProcess(theeminusStepCut,-1,-1,4);

theeminusStepCut->SetMaxStep(MaxChargedStep) ;


// Construct processes for positron

theeplusIonisation = new G4eIonisation();

theeplusBremsstrahlung = new G4eBremsstrahlung();

theeplusStepCut = new StepCut();

pmanager->AddProcess(theeplusIonisation,-1,2,2);

pmanager->AddProcess(theeplusBremsstrahlung,-1,-1,3);

pmanager->AddProcess(theeplusStepCut,-1,-1,5);

theeplusStepCut->SetMaxStep(MaxChargedStep) ;



// Construct processes for muon+

StepCut* muonStepCut = new StepCut();

E.3 168

G4MuIonisation* themuIonisation = new G4MuIonisation() ;

pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);

pmanager->AddProcess(themuIonisation,-1,2,2);

pmanager->AddProcess(new G4MuBremsstrahlung(),-1,-1,3);

pmanager->AddProcess(new G4MuPairProduction(),-1,-1,4);

pmanager->AddProcess( muonStepCut,-1,-1,3);

muonStepCut->SetMaxStep(MaxChargedStep) ;

else if (

particleName == "proton"

|| particleName == "antiproton"

|| particleName == "pi+"

|| particleName == "pi-"

|| particleName == "kaon+"

|| particleName == "kaon-"

)

StepCut* thehadronStepCut = new StepCut();

G4hIonisation* thehIonisation = new G4hIonisation() ;

G4MultipleScattering* thehMultipleScattering =

new G4MultipleScattering() ;

pmanager->AddProcess(thehMultipleScattering,-1,1,1);

pmanager->AddProcess(thehIonisation,-1,2,2);

pmanager->AddProcess( thehadronStepCut,-1,-1,3);

thehadronStepCut->SetMaxStep(MaxChargedStep) ;

E.3 169

/*








// gamma

pmanager->AddDiscreteProcess(new G4PhotoElectricEffect);

pmanager->AddDiscreteProcess(new G4ComptonScattering);

pmanager->AddDiscreteProcess(new G4GammaConversion);


//electron





//positron




pmanager->AddProcess(new G4eplusAnnihilation, 0,-1,4);



//muon


pmanager->AddProcess(new G4MuIonisation, -1, 2,2);

pmanager->AddProcess(new G4MuBremsstrahlung, -1, 3,3);

pmanager->AddProcess(new G4MuPairProduction, -1, 4,4);

else if ((!particle->IsShortLived()) &&

(particle->GetPDGCharge() != 0.0) &&

(particle->GetParticleName() != "chargedgeantino"))

//all others charged particles except geantino


pmanager->AddProcess(new G4hIonisation, -1, 2,2);

E.3 170

//step limit

////pmanager->AddProcess(new G4StepLimiter, -1,-1,3);

///pmanager->AddProcess(new G4UserSpecialCuts, -1,-1,4);

*/


#include "G4Decay.hh" void PhysicsList::ConstructGeneral()

// Add Decay Process

G4Decay* theDecayProcess = new G4Decay();





if (theDecayProcess->IsApplicable(*particle))

pmanager ->AddProcess(theDecayProcess);

// set ordering for PostStepDoIt and AtRestDoIt

pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);

pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);

#include "G4Region.hh" #include "G4RegionStore.hh" #include

"G4ProductionCuts.hh"

void PhysicsList::SetCuts()

G4Timer theTimer ;

theTimer.Start() ;

G4cout << "PhysicsList::SetCuts:";

G4cout << "CutLength : " << G4BestUnit(defaultCutValue,"Length") << G4endl;

// set cut values for gamma at first and for e- second and next for e+,

// because some processes for e+/e- need cut values for gamma

SetCutValue(cutForGamma,"gamma");

SetCutValue(cutForElectron,"e-");

SetCutValue(cutForElectron,"e+");

G4Region* reg4 = G4RegionStore::GetInstance()->GetRegion("Gas_log");

G4ProductionCuts* cuts4 = new G4ProductionCuts;

E.3 171

cuts4->SetProductionCut(0.01*mm);

reg4->SetProductionCuts(cuts4);

G4double lowLimit = 1. * eV;

G4double highLimit = 100. * GeV;

G4ProductionCutsTable::GetProductionCutsTable()->

SetEnergyRange(lowLimit, highLimit);

if (verboseLevel>0) DumpCutValuesTable();

theTimer.Stop();

G4cout.precision(6);

G4cout << G4endl ;

G4cout <<

"total time(SetCuts)=" << theTimer.GetUserElapsed() << " s " <<G4endl;

E.3.10. PrimaryGeneratorAction.cc



#include "G4Event.hh" #include "G4ParticleGun.hh" #include

"G4ParticleTable.hh" #include "G4ParticleDefinition.hh" #include

"globals.hh"


PrimaryGeneratorAction::PrimaryGeneratorAction()

//PrimaryGeneratorAction::PrimaryGeneratorAction(DetectorConstruction* det)

//:detector(det)

particleGun = new G4ParticleGun(1);

G4ParticleDefinition* particle= G4ParticleTable::GetParticleTable()->

FindParticle("e-");


E.3 172



/*

G4int n_particle = 1;

particleGun = new G4ParticleGun(n_particle);

// default particle

G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();

G4ParticleDefinition* particle = particleTable->FindParticle("proton");




*/


PrimaryGeneratorAction::~PrimaryGeneratorAction()

delete particleGun;


void PrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent)

//this function is called at the begining of event

//

particleGun->SetParticlePosition(G4ThreeVector(0.*cm,0.*cm,2.0*cm));

particleGun->GeneratePrimaryVertex(anEvent);


E.3 173

E.3.11. RunAction.cc


#include "DetectorConstruction.hh" #include

"PrimaryGeneratorAction.hh" #include "HistoManager.hh"

#include "G4Run.hh" #include "G4RunManager.hh" #include

"G4UnitsTable.hh" #include "G4EmCalculator.hh"

#include "Randomize.hh" #include <iomanip>


RunAction::RunAction(DetectorConstruction* det,

PrimaryGeneratorAction* prim,

HistoManager* histo)

: detector(det), primary(prim), ProcCounter(0), histoManager(histo)

totalEventCount=0;


RunAction::~RunAction()


void RunAction::BeginOfRunAction(const G4Run* aRun)

G4cout << "### Run " << aRun->GetRunID() << " start." << G4endl;

// save Rndm status

// G4RunManager::GetRunManager()->SetRandomNumberStore(false);

// CLHEP::HepRandom::showEngineStatus();

if (ProcCounter) delete ProcCounter;

ProcCounter = new ProcessesCount;

totalEventCount = 0;

photonStats.Clear();

electronStats.Clear();

positronStats.Clear();

histoManager->book();

E.3 174


void RunAction::FillData(const G4String & particleName,


G4double /* phi*/,



photonStats.FillData(kinEnergy, costheta, longitudinalPolarization);


electronStats.FillData(kinEnergy, costheta, longitudinalPolarization);

else if (particleName=="e+")

positronStats.FillData(kinEnergy, costheta, longitudinalPolarization);

void RunAction::CountProcesses(G4String procName)

// is the process already counted ?

// *AS* change to std::map?!

size_t nbProc = ProcCounter->size();

size_t i = 0;

while ((i<nbProc)&&((*ProcCounter)[i]->GetName()!=procName)) i++;

if (i == nbProc) ProcCounter->push_back( new OneProcessCount(procName));

(*ProcCounter)[i]->Count();


void RunAction::EndOfRunAction(const G4Run* aRun)

G4int NbOfEvents = aRun->GetNumberOfEvent();

if (NbOfEvents == 0) return;

G4int prec = G4cout.precision(5);

//G4Material* material = detector->GetMaterial();

//G4double density = material->GetDensity();

G4ParticleDefinition* particle =

primary->GetParticleGun()->GetParticleDefinition();

G4String Particle = particle->GetParticleName();

G4double energy = primary->GetParticleGun()->GetParticleEnergy();

G4cout << "\n The run consists of " << NbOfEvents << " "<< Particle << " of "

<< G4BestUnit(energy,"Energy") << " through " << G4endl;

E.3 175

//<< G4BestUnit(detector->GetBoxSizeZ(),"Length") << " of "

//<< material->GetName() << " (density: "

//<< G4BestUnit(density,"Volumic Mass") << ")" << G4endl;

//frequency of processes

G4cout << "\n Process calls frequency --->\n";

for (size_t i=0; i< ProcCounter->size();i++)

G4String procName = (*ProcCounter)[i]->GetName();

G4int count = (*ProcCounter)[i]->GetCounter();

G4cout << "\t" << procName << " = " << count<<"\n";

if (totalEventCount == 0) return;

G4cout<<" Gamma: \n";

photonStats.PrintResults(totalEventCount);

G4cout<<" Electron: \n";

electronStats.PrintResults(totalEventCount);

G4cout<<" Positron: \n";

positronStats.PrintResults(totalEventCount);

//cross check from G4EmCalculator

// G4cout << "\n Verification from G4EmCalculator. \n";

// G4EmCalculator emCal;

//restore default format

G4cout.precision(prec);

// write out histograms

histoManager->save();

// show Rndm status

CLHEP::HepRandom::showEngineStatus();


void RunAction::EventFinished()

++totalEventCount;

photonStats.EventFinished();

electronStats.EventFinished();

positronStats.EventFinished();

E.3 176


RunAction::ParticleStatistics::ParticleStatistics()

: currentNumber(0),

totalNumber(0), totalNumber2(0),

sumEnergy(0), sumEnergy2(0),

sumPolarization(0), sumPolarization2(0),

sumCosTheta(0), sumCosTheta2(0)


RunAction::ParticleStatistics::~ParticleStatistics()


void RunAction::ParticleStatistics::EventFinished()

totalNumber+=currentNumber;

totalNumber2+=currentNumber*currentNumber;

currentNumber=0;


void RunAction::ParticleStatistics:: FillData(G4double kinEnergy,

G4double costheta,


++currentNumber;

sumEnergy+=kinEnergy;

sumEnergy2+=kinEnergy*kinEnergy;

sumPolarization+=longitudinalPolarization;

sumPolarization2+=longitudinalPolarization*longitudinalPolarization;

sumCosTheta+=costheta;

sumCosTheta2+=costheta*costheta;


void RunAction::ParticleStatistics::PrintResults(G4int

totalNumberOfEvents)

G4cout<<"Mean Number per Event :"

<<G4double(totalNumber)/G4double(totalNumberOfEvents)<<"\n";

if (totalNumber==0) totalNumber=1;

E.3 177

G4double energyMean=sumEnergy/totalNumber;

G4double energyRms=std::sqrt(sumEnergy2/totalNumber-energyMean*energyMean);

G4cout<<"Mean Energy :"<< G4BestUnit(energyMean,"Energy")

<<" +- "<<G4BestUnit(energyRms,"Energy")<<"\n";

G4double polarizationMean=sumPolarization/totalNumber;

G4double polarizationRms=

std::sqrt(sumPolarization2/totalNumber-polarizationMean*polarizationMean);

G4cout<<"Mean Polarization :"<< polarizationMean

<<" +- "<<polarizationRms<<"\n";


void RunAction::ParticleStatistics::Clear()

currentNumber=0;

totalNumber=totalNumber2=0;

sumEnergy=sumEnergy2=0;

sumPolarization=sumPolarization2=0;

sumCosTheta=sumCosTheta2=0;


E.3.12. StepCut.cc

#include "StepCut.hh"

#include "G4Step.hh" #include "G4UserLimits.hh" #include

"G4VParticleChange.hh" #include "G4EnergyLossTables.hh"

StepCut::StepCut(const G4String& aName)

: G4VDiscreteProcess(aName),MaxChargedStep(DBL_MAX)

if (verboseLevel>0)

G4cout << GetProcessName() << " is created "<< G4endl;

StepCut::~StepCut()

StepCut::StepCut(StepCut& right)

:G4VDiscreteProcess(right)

E.3 178

void StepCut::SetMaxStep(G4double step)

MaxChargedStep = step ;

E.3.13. StepMax.cc

#include "StepMax.hh" #include "StepMaxMessenger.hh"


StepMax::StepMax(const G4String& processName)

: G4VDiscreteProcess(processName),MaxChargedStep(DBL_MAX)

pMess = new StepMaxMessenger(this);


StepMax::~StepMax() delete pMess;


G4bool StepMax::IsApplicable(const G4ParticleDefinition& particle)

return (particle.GetPDGCharge() != 0.);


void StepMax::SetMaxStep(G4double step) MaxChargedStep = step;


G4double StepMax::PostStepGetPhysicalInteractionLength(const

G4Track& aTrack,

G4double,

G4ForceCondition* condition )



E.3 179




(aTrack.GetVolume()->GetName() != "World"))

ProposedStep = MaxChargedStep;



G4VParticleChange* StepMax::PostStepDoIt(const G4Track& aTrack,

const G4Step&)

// do nothing




E.3.14. StepMaxMessenger.cc

#include "StepMaxMessenger.hh"

#include "StepMax.hh" #include "G4UIcmdWithADoubleAndUnit.hh"


StepMaxMessenger::StepMaxMessenger(StepMax* stepM) :pStepMax(stepM)

StepMaxCmd = new G4UIcmdWithADoubleAndUnit("/testem/stepMax",this);

StepMaxCmd->SetGuidance("Set max allowed step length");

StepMaxCmd->SetParameterName("mxStep",false);

StepMaxCmd->SetRange("mxStep>0.");

StepMaxCmd->SetUnitCategory("Length");


StepMaxMessenger::~StepMaxMessenger()

E.3 180

delete StepMaxCmd;


void StepMaxMessenger::SetNewValue(G4UIcommand* command, G4String

newValue)

if (command == StepMaxCmd)

pStepMax->SetMaxStep(StepMaxCmd->GetNewDoubleValue(newValue));


E.3.15. SteppingAction.cc

#include "SteppingAction.hh" #include "DetectorConstruction.hh"

#include "PrimaryGeneratorAction.hh" #include "RunAction.hh"

#include "HistoManager.hh"

#include "G4RunManager.hh" #include "G4PolarizationHelper.hh"


SteppingAction::SteppingAction(DetectorConstruction* det,

PrimaryGeneratorAction* prim, RunAction* RuAct,

HistoManager* Hist)

:detector(det), primary(prim), runAction(RuAct), histoManager(Hist)


SteppingAction::~SteppingAction()


void SteppingAction::UserSteppingAction(const G4Step* aStep)

G4StepPoint* prePoint = aStep->GetPreStepPoint();

G4StepPoint* endPoint = aStep->GetPostStepPoint();

G4String procName = endPoint->GetProcessDefinedStep()->GetProcessName();

runAction->CountProcesses(procName);

//if (prePoint->GetTouchableHandle()->GetVolume()==detector->GetBox() &&

E.3 181

// endPoint->GetTouchableHandle()->GetVolume()==detector->GetWorld())

if ( prePoint->GetTouchableHandle()->GetVolume()==detector->GetGasRPC()

&&

endPoint->GetTouchableHandle()->GetVolume()==detector->GetGasRPC())

G4Track* aTrack = aStep->GetTrack();

G4String

particleName = aTrack->GetDynamicParticle()->GetDefinition()->

GetParticleName();

// G4cout<<"a "<<particleName<<" left the Box \n";


G4ThreeVector position = endPoint->GetPosition();

G4double positionX = prePoint->GetPosition().x();

G4double positionY = prePoint->GetPosition().y();


G4ThreeVector direction = endPoint->GetMomentumDirection();

G4double kinEnergy = prePoint->GetKineticEnergy();

G4ThreeVector beamDirection =

primary->GetParticleGun()->GetParticleMomentumDirection();

G4double polZ = endPoint->GetPolarization().z();

G4double costheta=direction*beamDirection;

G4double

xdir=direction*G4PolarizationHelper::GetParticleFrameX(beamDirection);

G4double

ydir=direction*G4PolarizationHelper::GetParticleFrameY(beamDirection);

G4double phi=std::atan2(ydir,xdir);


histoManager->

FillHistos(particleName,kinEnergy,costheta,phi,polZ,positionX,positionY);


runAction->FillData(particleName,kinEnergy,costheta,phi,polZ);

E.4 182


E.4. Archivos contenidos en la carpeta include

E.4.1. DetectorConstruction.hh

#ifndef DetectorConstruction_H #define DetectorConstruction_H 1

#include "globals.hh" #include "G4VUserDetectorConstruction.hh"


#include "G4ios.hh"

class G4Box; class G4LogicalVolume; class G4VPhysicalVolume; class

G4Material; class DetectorMessenger; class ElectricFieldSetup; class

G4UniformMagField;

class DetectorConstruction : public G4VUserDetectorConstruction

public:

DetectorConstruction();

~DetectorConstruction();

G4VPhysicalVolume* Construct();

//void SetMagField(G4double);

const G4VPhysicalVolume* GetWorld() return VolumenGeneral_phys;;

const G4VPhysicalVolume* GetGasRPC() return GasC2H2F4_phys;;

private:

// Logical volumes

E.4 183

//

G4LogicalVolume* VolumenGeneral_log;

G4LogicalVolume* Baquelita_log;

G4LogicalVolume* Grafito_log;

G4LogicalVolume* Polietileno_log;

G4LogicalVolume* GasC2H2F4_log;

G4LogicalVolume* Aluminio_log;

// Physical volumes

//

G4VPhysicalVolume* VolumenGeneral_phys;

G4VPhysicalVolume* Baquelita_phys;

G4VPhysicalVolume* Grafito_phys;

G4VPhysicalVolume* Polietileno_phys;

G4VPhysicalVolume* GasC2H2F4_phys;

G4VPhysicalVolume* Aluminio_phys;

ElectricFieldSetup* fEmFieldSetup; // pointer to the field helper

//ExN01MagneticField* fpMagField; // pointer to the magnetic field

DetectorMessenger* detectorMessenger; // pointer to the Messenger

;

#endif

E.4.2. DetectorMessenger.hh

#ifndef DetectorMessenger_h #define DetectorMessenger_h 1


class DetectorConstruction; class G4UIdirectory; class

G4UIcmdWithAString; class G4UIcmdWithADoubleAndUnit; class

G4UIcmdWithoutParameter;


class DetectorMessenger: public G4UImessenger

public:

E.4 184

DetectorMessenger(DetectorConstruction* );

~DetectorMessenger();


private:

DetectorConstruction* Detector;

;


#endif

E.4.3. ElectricFieldSetup.hh

#ifndef ElectricFieldSetup_H #define ElectricFieldSetup_H

#include "G4ElectricField.hh" #include "G4UniformElectricField.hh"

class G4FieldManager; class G4ChordFinder; class G4EquationOfMotion;

class G4Mag_EqRhs; class G4EqMagElectricField; class

G4MagIntegratorStepper; class G4MagInt_Driver; class FieldMessenger;

class ElectricFieldSetup public:

ElectricFieldSetup(G4ThreeVector) ; // The value of the field

ElectricFieldSetup() ; // A zero field

~ElectricFieldSetup() ;

void SetStepperType( G4int i) fStepperType = i ;

void SetStepper();

void SetMinStep(G4double s) fMinStep = s ;

void UpdateField();

void SetFieldValue(G4ThreeVector fieldVector);

void SetFieldValue(G4double fieldValue);

E.4 185

G4ThreeVector GetConstantFieldValue();

protected:

// Find the global Field Manager

G4FieldManager* GetGlobalFieldManager() ;

private:

G4FieldManager* fFieldManager ;

G4ChordFinder* fChordFinder ;

G4EqMagElectricField* fEquation ;

G4ElectricField* fEMfield;

G4ThreeVector fElFieldValue ;

G4MagIntegratorStepper* fStepper ;

G4MagInt_Driver* fIntgrDriver;

G4int fStepperType ;

G4double fMinStep ;

FieldMessenger* fFieldMessenger;

;

#endif

E.4.4. EventAction.hh

#ifndef EventAction_h #define EventAction_h 1

#include "G4UserEventAction.hh" #include "globals.hh"

class EventActionMessenger; class RunAction;


class EventAction : public G4UserEventAction

public:

EventAction(RunAction *);

E.4 186

~EventAction();

public:

void BeginOfEventAction(const G4Event*);

void EndOfEventAction(const G4Event*);

void SetPrintModulo(G4int val) printModulo = val;;

private:

G4int printModulo;

EventActionMessenger* eventMessenger;


;


#endif

E.4.5. EventActionMessenger.hh

#ifndef EventActionMessenger_h #define EventActionMessenger_h 1


class EventAction; class G4UIdirectory; class G4UIcmdWithAnInteger;


class EventActionMessenger: public G4UImessenger

public:

EventActionMessenger(EventAction*);

~EventActionMessenger();


private:

EventAction* eventAction;

G4UIdirectory* eventDir;

G4UIcmdWithAnInteger* PrintCmd;

;


E.4 187

#endif

E.4.6. FieldMessenger.hh

#ifndef FieldMessenger_h #define FieldMessenger_h 1

#include "globals.hh" #include "G4UImessenger.hh"

class ElectricFieldSetup; class G4UIdirectory; class

G4UIcmdWithAString; class G4UIcmdWithAnInteger; class

G4UIcmdWithADoubleAndUnit; class G4UIcmdWithoutParameter;

class FieldMessenger: public G4UImessenger

public:

FieldMessenger(ElectricFieldSetup* );

~FieldMessenger();


void SetNewValue(G4UIcommand*, G4int);

private:

ElectricFieldSetup* fEFieldSetup;

G4UIdirectory* detDir;

G4UIcmdWithAnInteger* StepperCmd;

G4UIcmdWithADoubleAndUnit* MagFieldCmd;

G4UIcmdWithADoubleAndUnit* MinStepCmd;

G4UIcmdWithoutParameter* UpdateCmd;

G4UIcmdWithAString* AbsMaterCmd;

;

#endif

E.4 188

E.4.7. HistoManager.hh

#ifndef HistoManager_h #define HistoManager_h 1



namespace AIDA

class IAnalysisFactory;

class ITree;

class IHistogram1D;

/////Mi agregado

class ICloud2D;

/////Mi agregado

class HistoMessenger;

const G4int MaxHisto = 13;


class HistoManager public:

HistoManager();

~HistoManager();

void SetFileName (const G4String& name) fileName[0] = name;;

void SetFileType (const G4String& name) fileType = name;;

void SetFileOption (const G4String& name) fileType = name;;

void book();

void save();

void SetHisto (G4int,G4int,G4double,G4double,const G4String& unit="none");

void FillHisto(G4int id, G4double e, G4double weight = 1.0);

void FillHistos(const G4String & particleName,



/////Mi agregado


/////Mi agregado

);

E.4 189

void RemoveHisto (G4int);

G4bool HistoExist (G4int id) return exist[id];

G4double GetHistoUnit(G4int id) return Unit[id];

G4double GetBinWidth (G4int id) return Width[id];

private:

G4String fileName[2];

G4String fileType;

G4String fileOption;

AIDA::IAnalysisFactory* af;

AIDA::ITree* tree;

AIDA::IHistogram1D* histo[MaxHisto];

/////Mi agregado

AIDA::ICloud2D* cloud;

/////Mi agregado

G4bool exist[MaxHisto];

G4String Label[MaxHisto];

G4String Title[MaxHisto];

G4int Nbins[MaxHisto];

G4double Vmin [MaxHisto];

G4double Vmax [MaxHisto];

G4double Unit [MaxHisto];

G4double Width[MaxHisto];

G4bool factoryOn;

HistoMessenger* histoMessenger;

;


#endif

E.4.8. HistoMessenger.hh

#ifndef HistoMessenger_h #define HistoMessenger_h 1


E.4 190


class HistoManager; class G4UIdirectory; class G4UIcommand; class

G4UIcmdWithAString; class G4UIcmdWithAnInteger;


class HistoMessenger: public G4UImessenger

public:

HistoMessenger(HistoManager* );

~HistoMessenger();

void SetNewValue(G4UIcommand* ,G4String );

private:


G4UIdirectory* histoDir;

G4UIcmdWithAString* factoryCmd;

G4UIcmdWithAString* typeCmd;

G4UIcmdWithAString* optionCmd;

G4UIcommand* histoCmd;

G4UIcmdWithAnInteger* rmhistoCmd;

;


#endif

E.4.9. PhysicsList.hh

#ifndef PhysicsList_h #define PhysicsList_h 1

#include "G4VUserPhysicsList.hh" #include "globals.hh"

class G4PhotoElectricEffect; class G4ComptonScattering; class

G4GammaConversion;

class G4MultipleScattering;

E.4 191

class G4PAIonisation ; class G4ForwardXrayTR ; class G4eIonisation;

class G4eBremsstrahlung; class G4eplusAnnihilation;

class G4MuIonisation; class G4MuBremsstrahlung; class

G4MuPairProduction;

class G4hIonisation; class G4hIonisationPlus;

class StepCut;

class DetectorConstruction; class PhysicsListMessenger;

class PhysicsList: public G4VUserPhysicsList

public:

PhysicsList( DetectorConstruction*);

~PhysicsList();

protected:

// Construct particle and physics

void ConstructParticle();

void ConstructProcess();

void SetCuts();

protected:

// these methods Construct particles

void ConstructBosons();

void ConstructLeptons();

void ConstructMesons();

void ConstructBarions();

protected:

// these methods Construct physics processes and register them

// void AddParameterisation();

void ConstructGeneral();

void ConstructEM();

public:

void SetGammaCut(G4double);

E.4 192

void SetElectronCut(G4double);


public:


private:

G4PhotoElectricEffect* thePhotoElectricEffect;

G4ComptonScattering* theComptonScattering;

G4GammaConversion* theGammaConversion;

G4MultipleScattering* theeminusMultipleScattering;

G4eIonisation* theeminusIonisation;

G4eBremsstrahlung* theeminusBremsstrahlung;

G4PAIonisation* fPAIonisation ;

G4ForwardXrayTR* fForwardXrayTR ;

G4MultipleScattering* theeplusMultipleScattering;

G4eIonisation* theeplusIonisation;

G4eBremsstrahlung* theeplusBremsstrahlung;

G4eplusAnnihilation* theeplusAnnihilation;

StepCut* theeminusStepCut ;

StepCut* theeplusStepCut ;

G4double cutForGamma;

G4double cutForElectron;

DetectorConstruction* pDet;

PhysicsListMessenger* physicsListMessenger;

;

#endif

E.4.10. PrimaryGeneratorAction.hh

#ifndef PrimaryGeneratorAction_h #define PrimaryGeneratorAction_h 1

E.4 193

#include "G4VUserPrimaryGeneratorAction.hh" #include

"G4ParticleGun.hh" #include "globals.hh"

//class G4ParticleGun;

class G4Event;

class PrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction

public:

PrimaryGeneratorAction();

~PrimaryGeneratorAction();

public:

void GeneratePrimaries(G4Event* anEvent);

G4ParticleGun* GetParticleGun() return particleGun;;

private:

G4ParticleGun* particleGun;

;

#endif

E.4.11. ProcessesCount.hh

#ifndef ProcessesCount_HH #define ProcessesCount_HH

#include "globals.hh" #include <vector>


class OneProcessCount public:

OneProcessCount(G4String name) Name=name; Counter=0;;

~OneProcessCount() ;

public:

G4String GetName() return Name;;

G4int GetCounter() return Counter;;

void Count() Counter++;;

private:

G4String Name; // process name

E.4 194

G4int Counter; // process counter

;


typedef std::vector<OneProcessCount*> ProcessesCount;

#endif

E.4.12. RunAction.hh

#ifndef RunAction_h #define RunAction_h 1

#include "G4UserRunAction.hh" #include "ProcessesCount.hh" #include

"globals.hh"



HistoManager; class G4Run;


class RunAction : public G4UserRunAction

class ParticleStatistics

public:

ParticleStatistics();

~ParticleStatistics();


void FillData(G4double kinEnergy, G4double costheta,


void PrintResults(G4int totalNumberOfEvents);

void Clear();

private:

G4int currentNumber;

G4int totalNumber, totalNumber2;

G4double sumEnergy, sumEnergy2;

G4double sumPolarization, sumPolarization2;

G4double sumCosTheta, sumCosTheta2;

;

E.4 195

public:

RunAction(DetectorConstruction*, PrimaryGeneratorAction*, HistoManager*);

virtual ~RunAction();

public:

void BeginOfRunAction(const G4Run*);

void EndOfRunAction(const G4Run*);

void CountProcesses(G4String);

void FillData(const G4String & particleName,




private:



ProcessesCount* ProcCounter;


G4int totalEventCount;

ParticleStatistics photonStats;

ParticleStatistics electronStats;

ParticleStatistics positronStats;

;


#endif

E.4.13. StepCut.hh

#ifndef StepCut_h #define StepCut_h 1

#include "G4ios.hh" #include "globals.hh" #include

"G4VDiscreteProcess.hh" #include "G4Step.hh"

class StepCut : public G4VDiscreteProcess

public:

E.4 196

StepCut(const G4String& processName ="UserStepCut" );

StepCut(StepCut &);

~StepCut();

G4double PostStepGetPhysicalInteractionLength(

const G4Track& track,


G4ForceCondition* condition

);

G4VParticleChange* PostStepDoIt(

const G4Track& ,

const G4Step&

);


protected:

// it is not needed here !

G4double GetMeanFreePath(const G4Track& aTrack,


G4ForceCondition* condition

);

private:

// hide assignment operator as private

StepCut & operator=(const StepCut &right);

private:

G4double MaxChargedStep ;

;

// inlined function members implementation

#include "G4Step.hh" #include "G4Track.hh" #include

"G4UserLimits.hh" #include "G4VParticleChange.hh" #include

"G4EnergyLossTables.hh"

inline G4double StepCut::PostStepGetPhysicalInteractionLength(

E.4 197

const G4Track& aTrack,

G4double,

G4ForceCondition* condition)






(aTrack.GetVolume()->GetName() == "Absorber") &&

(aTrack.GetDynamicParticle()->GetDefinition()->GetPDGCharge() != 0.))

ProposedStep = MaxChargedStep ;


inline G4VParticleChange* StepCut::PostStepDoIt(

const G4Track& aTrack,

const G4Step&

)

// do nothing



inline G4double StepCut::GetMeanFreePath(const G4Track&,

G4double,

G4ForceCondition*)

return 0.;

#endif

E.4.14. StepMax.hh

#ifndef StepMax_h #define StepMax_h 1

#include "globals.hh" #include "G4VDiscreteProcess.hh" #include

E.4 198

"G4ParticleDefinition.hh" #include "G4Step.hh"

class StepMaxMessenger;


class StepMax : public G4VDiscreteProcess

public:

StepMax(const G4String& processName ="stepMax");

~StepMax();

G4bool IsApplicable(const G4ParticleDefinition&);


G4double GetMaxStep() return MaxChargedStep;;

G4double PostStepGetPhysicalInteractionLength( const G4Track& track,


G4ForceCondition* condition);

G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);

G4double GetMeanFreePath(const G4Track&, G4double, G4ForceCondition*)

return 0.;; // it is not needed here !

private:


StepMaxMessenger* pMess;

;


#endif

E.4.15. StepMaxMessenger.hh

#ifndef StepMaxMessenger_h #define StepMaxMessenger_h 1


class StepMax; class G4UIcmdWithADoubleAndUnit;

E.4 199


class StepMaxMessenger: public G4UImessenger

public:

StepMaxMessenger(StepMax*);

~StepMaxMessenger();


private:

StepMax* pStepMax;

G4UIcmdWithADoubleAndUnit* StepMaxCmd;

;


#endif

E.4.16. SteppingAction.hh

#ifndef SteppingAction_h #define SteppingAction_h 1

#include "G4UserSteppingAction.hh" #include "globals.hh"


RunAction; class HistoManager;


class SteppingAction : public G4UserSteppingAction

public:

SteppingAction(DetectorConstruction*, PrimaryGeneratorAction*, RunAction*,

HistoManager*);

~SteppingAction();

void UserSteppingAction(const G4Step*);

private:





;

E.4 200


#endif

Bibliografía

[1] Roa Diego. Estudio de ruido producido por neutrones térmicos en las cámarasRPC de CMS . Universidad de los Andes, Facultad de Ciencias Departamentode Física, 2007.

[2] Large Hadron Collider.Disponible en: http://en.wikipedia.org/wiki/Large_Hadron_Collider

[3] The LHC experiments. Disponible en:http://public.web.cern.ch/public/en/LHC/LHCExperiments-en.html

[4] Why the LHC, A few unanswered questions. Disponible en:http://public.web.cern.ch/public/en/LHC/WhyLHC-en.html

[5] Ellis, J. Physics at LHC. Acta Phys. Polon. B38, 1071-1092; preprint at<http://arxiv.org/abs/hep-ph/0611237>(2007).

[6] LHC Home page. http://lhc.web.cern.ch/lhc/

[7] What is CMS. Disponible en:http://www.uslhc.us/What_is_the_LHC/Experiments/CMS

[8] Compact Muon Solenoid. Disponible en:http://en.wikipedia.org/wiki/Compact_Muon_Solenoid

[9] CMS installs the world's largest silicon detector, CERN Courier, Feb 15, 2008

[10] A. Das y T. Ferbel, Introduction to nuclear and particle physics. New York:John Wiley & Sons, 1994.

[11] Escuela Técnica Superior de Ingenieros Industriales de Madrid, Prác-ticas de física nuclear II. http://www.din.upm.es/teaching/lab-s2-web/geiger/practica1.pdf

[12] A RESISTIVE PLATE CHAMBER muon detector for the CMS experimentat LHC G. Bellia, C, De Vecchia, et all.

[13] CMS Collaboration, CMS Muon Technical Design Report. CERN LHCC 97-32. Geneva, Suiza, Diciembre 1997.

E.4 202

[14] M. Abbrescia et al., "Properties of C2H2F4 based gas mixtures for ava-lanche mode operation of Resistive Plate Chambers", CMS Note 97/004.Nucl.Instr.Meth., in print.

[14] Compilador. Disponible en: http://es.wikipedia.org/wiki/Compilador

Simulación de Monte-Carlo de Cámaras de Placas Resistivas ...

Documents

Transcript of Simulación de Monte-Carlo de Cámaras de Placas Resistivas ...