simulación de monte-carlo de cámaras de placas resistivas
TRANSCRIPT
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
`/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/2.0.3.1
/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
`/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/2.0.3.1
/CLHEP/Units'
Making install in Units make[2]: Entering directory
`/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/2.0.3.1
/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
`/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/2.0.3.1/CLHEP'
make[1]: Leaving directory
`/afs/slac.stanford.edu/home/andres/Simulacion/CLHEP/2.0.3.1/CLHEP'
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
geant4.9.0/ReleaseNotes/Patch4.4.0-2.txt
geant4.9.0/ReleaseNotes/Patch4.4.1-1.txt
Y finalizar con algo similar a lo siguiente:
geant4.9.0/source/visualization/modeling/src/
G4TrajectoryOriginVolumeFilter.cc
A.6 67
geant4.9.0/source/visualization/modeling/src/
G4TrajectoryParticleFilter.cc
geant4.9.0/source/visualization/modeling/src/
G4VModel.cc
geant4.9.0/source/visualization/modeling/src/
G4VTrajectoryModel.cc
geant4.9.0/source/visualization/modeling/src/
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
PATH=$PATH:∼/aida/java/jdk1.6.0_05/bin/
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:
PATH=$PATH:∼/aida/java/jdk1.6.0_05/bin/
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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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_x = 0.0*mm;
G4double baquePos2_y = 0.0*mm;
G4double baquePos2_z = -2.0*mm;
Baquelita_phys = new G4PVPlacement(0,
G4ThreeVector(baquePos2_x,baquePos2_y,baquePos2_z),
Baquelita_log,"Baque",VolumenGeneral_log,false,1);
//------------------------------ 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_x = 0.0*mm;
G4double grafiPos2_y = 0.0*mm;
G4double grafiPos2_z = -3.1*mm;
Grafito_phys = new G4PVPlacement(0,
G4ThreeVector(grafiPos2_x,grafiPos2_y,grafiPos2_z),
Grafito_log,"Grafi",VolumenGeneral_log,false,1);
//------------------------------ 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_x = 0.0*mm;
G4double PoliPos2_y = 0.0*mm;
G4double PoliPos2_z = -3.3*mm;
Polietileno_phys = new G4PVPlacement(0,
G4ThreeVector(PoliPos2_x,PoliPos2_y,PoliPos2_z),
Polietileno_log,"Poli",VolumenGeneral_log,false,1);
//------------------------------ 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));
atb->SetForceSolid(true);
logicGap->SetVisAttributes(atb);
D.3 98
*/
G4VisAttributes* atb= new G4VisAttributes(G4Colour(1.0,0.0,0.0,1.0));
atb->SetForceSolid(true);
Aluminio_log->SetVisAttributes(atb);
G4VisAttributes* atb= new G4VisAttributes(G4Colour(1.0,1.0,1.0));
atb->SetForceSolid(true);
CorreccionAngulo_log ->SetVisAttributes(atb);
return VolumenGeneral_phys;
//void ExN01DetectorConstruction::SetMagField(G4double fieldValue)
//
// fpMagField->SetFieldValue(fieldValue);
//
D.3.2. DetectorMessenger.cc
#include "DetectorMessenger.hh"
#include "DetectorConstruction.hh" #include "G4UIdirectory.hh"
#include "G4UIcmdWithAString.hh" #include
"G4UIcmdWithADoubleAndUnit.hh" #include "G4UIcmdWithoutParameter.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorMessenger::DetectorMessenger(DetectorConstruction * Det)
:Detector(Det)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorMessenger::~DetectorMessenger()
D.3 99
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorMessenger::SetNewValue(G4UIcommand*, G4String)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
EventAction::EventAction(RunAction * ra)
:printModulo(10000),eventMessenger(0),runAction(ra)
eventMessenger = new EventActionMessenger(this);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
EventAction::~EventAction()
delete eventMessenger;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
D.3.4. EventActionMessenger.cc
#include "EventActionMessenger.hh"
#include "EventAction.hh"
#include "G4UIdirectory.hh" #include "G4UIcmdWithAnInteger.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
EventActionMessenger::~EventActionMessenger()
delete PrintCmd;
delete eventDir;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void EventActionMessenger::SetNewValue(G4UIcommand* command,
G4String newValue)
if (command == PrintCmd)
eventAction->SetPrintModulo(PrintCmd->GetNewIntValue(newValue));
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
D.3.5. HistoManager.cc
#include "HistoManager.hh" #include "HistoMessenger.hh" #include
"G4UnitsTable.hh"
#ifdef G4ANALYSIS_USE #include "AIDA/AIDA.h" #endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
HistoManager::~HistoManager()
delete histoMessenger;
#ifdef G4ANALYSIS_USE
delete af;
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
for (G4int k=0; k<MaxHisto; k++)
if (exist[k])
histo[k] = hf->createHistogram1D( Label[k], Title[k],
Nbins[k], Vmin[k], Vmax[k]);
factoryOn = true;
///////////Mi agregado
cloud=hf->createCloud2D( "Scatter Plot X vs Y");
////////////Mi agregado
delete hf;
if(factoryOn)
G4cout << "\n----> Histogram Tree is opened " << fileName[1] << G4endl;
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
///////////Mi agregado
cloud->fill(posX, posY);
////////////Mi agregado
else if (particleName=="e-")
id=5;
///////////Mi agregado
//cloud->fill(posX, posY);
////////////Mi agregado
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;
#ifdef G4ANALYSIS_USE
if(exist[ih]) histo[ih]->fill(e/Unit[ih], weight);
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void HistoManager::RemoveHisto(G4int ih)
if (ih > MaxHisto)
G4cout << "---> warning from HistoManager::RemoveHisto() : histo " << ih
<< "does not exist" << G4endl;
return;
histo[ih] = 0; exist[ih] = false;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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");
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
HistoMessenger::~HistoMessenger()
delete rmhistoCmd;
delete histoCmd;
delete optionCmd;
delete typeCmd;
delete factoryCmd;
delete histoDir;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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));
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
D.3.7. PhysicsList.hh
#include "globals.hh" #include "PhysicsList.hh"
#include "G4ProcessManager.hh" #include "G4ParticleTypes.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PhysicsList::PhysicsList(): G4VUserPhysicsList()
defaultCutValue = 0.1*mm;
SetVerboseLevel(1);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PhysicsList::~PhysicsList()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PhysicsList::ConstructBosons()
// pseudo-particles
G4Geantino::GeantinoDefinition();
G4ChargedGeantino::ChargedGeantinoDefinition();
D.3 110
// gamma
G4Gamma::GammaDefinition();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PhysicsList::ConstructBaryons()
D.3 111
// barions
G4Proton::ProtonDefinition();
G4AntiProton::AntiProtonDefinition();
G4Neutron::NeutronDefinition();
G4AntiNeutron::AntiNeutronDefinition();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PhysicsList::ConstructProcess()
AddTransportation();
ConstructEM();
ConstructGeneral();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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 G4MultipleScattering,-1, 1,1);
pmanager->AddProcess(new G4eIonisation, -1, 2,2);
pmanager->AddProcess(new G4eBremsstrahlung, -1, 3,3);
pmanager->AddProcess(new G4eplusAnnihilation, 0,-1,4);
else if( particleName == "mu+" ||
particleName == "mu-" )
//muon
pmanager->AddProcess(new G4MultipleScattering,-1, 1,1);
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 G4MultipleScattering,-1, 1,1);
pmanager->AddProcess(new G4hIonisation, -1, 2,2);
//step limit
////pmanager->AddProcess(new G4StepLimiter, -1,-1,3);
///pmanager->AddProcess(new G4UserSpecialCuts, -1,-1,4);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4Decay.hh" void PhysicsList::ConstructGeneral()
// Add Decay Process
G4Decay* theDecayProcess = new G4Decay();
theParticleIterator->reset();
D.3 113
while( (*theParticleIterator)() )
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
if (theDecayProcess->IsApplicable(*particle))
pmanager ->AddProcess(theDecayProcess);
// set ordering for PostStepDoIt and AtRestDoIt
pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
D.3.8. PrimaryGeneratorAction.cc
#include "PrimaryGeneratorAction.hh"
#include "DetectorConstruction.hh"
#include "G4Event.hh" #include "G4ParticleGun.hh" #include
"G4ParticleTable.hh" #include "G4ParticleDefinition.hh" #include
"globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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");
particleGun->SetParticleDefinition(particle);
particleGun->SetParticleMomentumDirection(G4ThreeVector(0.,0.,-1.0));
particleGun->SetParticleEnergy(1.0*GeV);
*/
D.3 115
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PrimaryGeneratorAction::~PrimaryGeneratorAction()
delete particleGun;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
D.3.9. RunAction.cc
#include "RunAction.hh"
#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>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::RunAction(DetectorConstruction* det,
PrimaryGeneratorAction* prim,
HistoManager* histo)
: detector(det), primary(prim), ProcCounter(0), histoManager(histo)
totalEventCount=0;
D.3 116
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::~RunAction()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::FillData(const G4String & particleName,
G4double kinEnergy, G4double costheta,
G4double /* phi*/,
G4double longitudinalPolarization)
if (particleName=="gamma")
photonStats.FillData(kinEnergy, costheta, longitudinalPolarization);
else if (particleName=="e-")
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::EventFinished()
++totalEventCount;
photonStats.EventFinished();
electronStats.EventFinished();
positronStats.EventFinished();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::ParticleStatistics::ParticleStatistics()
: currentNumber(0),
totalNumber(0), totalNumber2(0),
sumEnergy(0), sumEnergy2(0),
sumPolarization(0), sumPolarization2(0),
sumCosTheta(0), sumCosTheta2(0)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::ParticleStatistics::~ParticleStatistics()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::ParticleStatistics::EventFinished()
totalNumber+=currentNumber;
totalNumber2+=currentNumber*currentNumber;
currentNumber=0;
D.3 119
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::ParticleStatistics:: FillData(G4double kinEnergy,
G4double costheta,
G4double longitudinalPolarization)
++currentNumber;
sumEnergy+=kinEnergy;
sumEnergy2+=kinEnergy*kinEnergy;
sumPolarization+=longitudinalPolarization;
sumPolarization2+=longitudinalPolarization*longitudinalPolarization;
sumCosTheta+=costheta;
sumCosTheta2+=costheta*costheta;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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";
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::ParticleStatistics::Clear()
currentNumber=0;
totalNumber=totalNumber2=0;
sumEnergy=sumEnergy2=0;
sumPolarization=sumPolarization2=0;
sumCosTheta=sumCosTheta2=0;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
D.3 120
D.3.10. StepMax.cc
#include "StepMax.hh" #include "StepMaxMessenger.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
StepMax::StepMax(const G4String& processName)
: G4VDiscreteProcess(processName),MaxChargedStep(DBL_MAX)
pMess = new StepMaxMessenger(this);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
StepMax::~StepMax() delete pMess;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4bool StepMax::IsApplicable(const G4ParticleDefinition& particle)
return (particle.GetPDGCharge() != 0.);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void StepMax::SetMaxStep(G4double step) MaxChargedStep = step;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4VParticleChange* StepMax::PostStepDoIt(const G4Track& aTrack,
const G4Step&)
// do nothing
aParticleChange.Initialize(aTrack);
return &aParticleChange;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
D.3.11. StepMaxMessenger.cc
#include "StepMaxMessenger.hh"
#include "StepMax.hh" #include "G4UIcmdWithADoubleAndUnit.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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");
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
StepMaxMessenger::~StepMaxMessenger()
delete StepMaxCmd;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void StepMaxMessenger::SetNewValue(G4UIcommand* command, G4String
newValue)
if (command == StepMaxCmd)
pStepMax->SetMaxStep(StepMaxCmd->GetNewDoubleValue(newValue));
D.3 122
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
SteppingAction::SteppingAction(DetectorConstruction* det,
PrimaryGeneratorAction* prim, RunAction* RuAct,
HistoManager* Hist)
:detector(det), primary(prim), runAction(RuAct), histoManager(Hist)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
SteppingAction::~SteppingAction()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
////cambiado y agregado por mi
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);
////modificado por mi
runAction->FillData(particleName,kinEnergy,costheta,phi,polZ);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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 "ExN01MagneticField.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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class DetectorMessenger: public G4UImessenger
public:
DetectorMessenger(DetectorConstruction* );
~DetectorMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
DetectorConstruction* Detector;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
D.4.4. EventActionMessenger.hh
#ifndef EventActionMessenger_h #define EventActionMessenger_h 1
#include "G4UImessenger.hh" #include "globals.hh"
class EventAction; class G4UIdirectory; class G4UIcmdWithAnInteger;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
D.4 127
class EventActionMessenger: public G4UImessenger
public:
EventActionMessenger(EventAction*);
~EventActionMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
EventAction* eventAction;
G4UIdirectory* eventDir;
G4UIcmdWithAnInteger* PrintCmd;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
D.4.5. HistoManager.hh
#ifndef HistoManager_h #define HistoManager_h 1
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
namespace AIDA
class IAnalysisFactory;
class ITree;
class IHistogram1D;
/////Mi agregado
class ICloud2D;
/////Mi agregado
class HistoMessenger;
const G4int MaxHisto = 13;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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,
G4double longitudinalPolarization,
/////Mi agregado
G4double posX, G4double posY
/////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;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
D.4.6. HistoMessenger.hh
#ifndef HistoMessenger_h #define HistoMessenger_h 1
#include "G4UImessenger.hh" #include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class HistoManager; class G4UIdirectory; class G4UIcommand; class
G4UIcmdWithAString; class G4UIcmdWithAnInteger;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
D.4.7. PhysicsList.hh
#ifndef PhysicsList_h #define PhysicsList_h 1
#include "G4VUserPhysicsList.hh" #include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class DetectorConstruction; class PrimaryGeneratorAction; class
HistoManager; class G4Run;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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,
G4double kinEnergy, G4double costheta, G4double phi,
G4double longitudinalPolarization);
void EventFinished();
private:
DetectorConstruction* detector;
PrimaryGeneratorAction* primary;
ProcessesCount* ProcCounter;
HistoManager* histoManager;
G4int totalEventCount;
ParticleStatistics photonStats;
ParticleStatistics electronStats;
ParticleStatistics positronStats;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
D.4 135
D.4.12. StepMaxMessenger.hh
#ifndef StepMaxMessenger_h #define StepMaxMessenger_h 1
#include "G4UImessenger.hh" #include "globals.hh"
class StepMax; class G4UIcmdWithADoubleAndUnit;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class StepMaxMessenger: public G4UImessenger
public:
StepMaxMessenger(StepMax*);
~StepMaxMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
StepMax* pStepMax;
G4UIcmdWithADoubleAndUnit* StepMaxCmd;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
D.4.13. SteppingAction.hh
#ifndef SteppingAction_h #define SteppingAction_h 1
#include "G4UserSteppingAction.hh" #include "globals.hh"
class DetectorConstruction; class PrimaryGeneratorAction; class
RunAction; class HistoManager;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class SteppingAction : public G4UserSteppingAction
public:
SteppingAction(DetectorConstruction*, PrimaryGeneratorAction*, RunAction*,
D.4 136
HistoManager*);
~SteppingAction();
void UserSteppingAction(const G4Step*);
private:
DetectorConstruction* detector;
PrimaryGeneratorAction* primary;
RunAction* runAction;
HistoManager* histoManager;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
DetectorConstruction* det;
det = new DetectorConstruction;
runManager->SetUserInitialization(det);
runManager->SetUserInitialization(new PhysicsList(det));
PrimaryGeneratorAction* prim;
/*
DetectorConstruction* det;
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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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 "ExN01MagneticField.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_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_x = 0.0*mm;
G4double baquePos2_y = 0.0*mm;
G4double baquePos2_z = -2.0*mm;
Baquelita_phys = new G4PVPlacement(0,
G4ThreeVector(baquePos2_x,baquePos2_y,baquePos2_z),
Baquelita_log,"Baque",VolumenGeneral_log,false,1);
//------------------------------ 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_x = 0.0*mm;
G4double grafiPos2_y = 0.0*mm;
G4double grafiPos2_z = -3.1*mm;
Grafito_phys = new G4PVPlacement(0,
G4ThreeVector(grafiPos2_x,grafiPos2_y,grafiPos2_z),
Grafito_log,"Grafi",VolumenGeneral_log,false,1);
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_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_x = 0.0*mm;
G4double PoliPos2_y = 0.0*mm;
G4double PoliPos2_z = -3.3*mm;
Polietileno_phys = new G4PVPlacement(0,
G4ThreeVector(PoliPos2_x,PoliPos2_y,PoliPos2_z),
Polietileno_log,"Poli",VolumenGeneral_log,false,1);
//------------------------------ 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);
*/
G4VisAttributes* atb= new G4VisAttributes(G4Colour(0.5,0.5,0.5));
atb->SetForceSolid(true);
Grafito_log->SetVisAttributes(atb);
E.3 146
G4VisAttributes* atb= new G4VisAttributes(G4Colour(1.0,1.0,1.0));
atb->SetForceSolid(true);
Baquelita_log->SetVisAttributes(atb);
G4VisAttributes* atb= new G4VisAttributes(G4Colour(1.0,0.0,0.0));
atb->SetForceSolid(true);
Aluminio_log->SetVisAttributes(atb);
G4VisAttributes* atb= new G4VisAttributes(G4Colour(1.0,1.0,0.0));
atb->SetForceSolid(true);
Polietileno_log->SetVisAttributes(atb);
return VolumenGeneral_phys;
E.3.2. DetectorMessenger.cc
#include "DetectorMessenger.hh"
#include "DetectorConstruction.hh" #include "G4UIdirectory.hh"
#include "G4UIcmdWithAString.hh" #include
"G4UIcmdWithADoubleAndUnit.hh" #include "G4UIcmdWithoutParameter.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorMessenger::DetectorMessenger(DetectorConstruction * Det)
:Detector(Det)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorMessenger::~DetectorMessenger()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorMessenger::SetNewValue(G4UIcommand*, G4String)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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.))
if(fEMfield) delete fEMfield;
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.
if(fEMfield) delete fEMfield;
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 "EventAction.hh"
#include "EventActionMessenger.hh"
#include "G4Event.hh" #include "G4TrajectoryContainer.hh" #include
"G4Trajectory.hh" #include "G4VVisManager.hh" #include
"G4UnitsTable.hh" #include "RunAction.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
EventAction::EventAction(RunAction * ra)
:printModulo(10000),eventMessenger(0),runAction(ra)
eventMessenger = new EventActionMessenger(this);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
E.3 152
EventAction::~EventAction()
delete eventMessenger;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void EventAction::BeginOfEventAction(const G4Event* evt)
G4int evtNb = evt->GetEventID();
//printing survey
if (evtNb%printModulo == 0)
G4cout << "\n---> Begin of Event: " << evtNb << G4endl;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
E.3.5. EventActionMessenger.cc
#include "EventActionMessenger.hh"
#include "EventAction.hh"
#include "G4UIdirectory.hh" #include "G4UIcmdWithAnInteger.hh"
E.3 153
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
EventActionMessenger::~EventActionMessenger()
delete PrintCmd;
delete eventDir;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void EventActionMessenger::SetNewValue(G4UIcommand* command,
G4String newValue)
if (command == PrintCmd)
eventAction->SetPrintModulo(PrintCmd->GetNewIntValue(newValue));
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
HistoManager::~HistoManager()
delete histoMessenger;
#ifdef G4ANALYSIS_USE
delete af;
#endif
E.3 157
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
for (G4int k=0; k<MaxHisto; k++)
if (exist[k])
histo[k] = hf->createHistogram1D( Label[k], Title[k],
Nbins[k], Vmin[k], Vmax[k]);
factoryOn = true;
///////////Mi agregado
cloud=hf->createCloud2D( "Scatter Plot X vs Y");
////////////Mi agregado
E.3 158
delete hf;
if(factoryOn)
G4cout << "\n----> Histogram Tree is opened " << fileName[1] << G4endl;
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
else if (particleName=="e-")
id=5;
///////////Mi agregado
cloud->fill(posX, posY);
////////////Mi agregado
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;
#ifdef G4ANALYSIS_USE
if(exist[ih]) histo[ih]->fill(e/Unit[ih], weight);
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void HistoManager::RemoveHisto(G4int ih)
if (ih > MaxHisto)
G4cout << "---> warning from HistoManager::RemoveHisto() : histo " << ih
<< "does not exist" << G4endl;
return;
histo[ih] = 0; exist[ih] = false;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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");
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
HistoMessenger::~HistoMessenger()
delete rmhistoCmd;
delete histoCmd;
delete optionCmd;
delete typeCmd;
delete factoryCmd;
delete histoDir;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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));
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PhysicsList::~PhysicsList()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PhysicsList::ConstructBosons()
// pseudo-particles
G4Geantino::GeantinoDefinition();
G4ChargedGeantino::ChargedGeantinoDefinition();
// gamma
G4Gamma::GammaDefinition();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PhysicsList::ConstructBarions()
// barions
G4Proton::ProtonDefinition();
G4AntiProton::AntiProtonDefinition();
G4Neutron::NeutronDefinition();
G4AntiNeutron::AntiNeutronDefinition();
E.3 166
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PhysicsList::ConstructProcess()
AddTransportation();
ConstructEM();
ConstructGeneral();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PhysicsList::ConstructEM()
theParticleIterator->reset();
while( (*theParticleIterator)() )
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma")
// 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);
else if (particleName == "e-")
// 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) ;
else if (particleName == "e+")
// 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) ;
else if( particleName == "mu+" ||
particleName == "mu-" )
// 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
/*
void PhysicsList::ConstructEM()
theParticleIterator->reset();
while( (*theParticleIterator)() )
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma")
// gamma
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 G4MultipleScattering,-1, 1,1);
pmanager->AddProcess(new G4eIonisation, -1, 2,2);
pmanager->AddProcess(new G4eBremsstrahlung, -1, 3,3);
pmanager->AddProcess(new G4eplusAnnihilation, 0,-1,4);
else if( particleName == "mu+" ||
particleName == "mu-" )
//muon
pmanager->AddProcess(new G4MultipleScattering,-1, 1,1);
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 G4MultipleScattering,-1, 1,1);
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);
*/
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4Decay.hh" void PhysicsList::ConstructGeneral()
// Add Decay Process
G4Decay* theDecayProcess = new G4Decay();
theParticleIterator->reset();
while( (*theParticleIterator)() )
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
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 "PrimaryGeneratorAction.hh"
#include "DetectorConstruction.hh"
#include "G4Event.hh" #include "G4ParticleGun.hh" #include
"G4ParticleTable.hh" #include "G4ParticleDefinition.hh" #include
"globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PrimaryGeneratorAction::PrimaryGeneratorAction()
//PrimaryGeneratorAction::PrimaryGeneratorAction(DetectorConstruction* det)
//:detector(det)
particleGun = new G4ParticleGun(1);
G4ParticleDefinition* particle= G4ParticleTable::GetParticleTable()->
FindParticle("e-");
particleGun->SetParticleDefinition(particle);
E.3 172
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");
particleGun->SetParticleDefinition(particle);
particleGun->SetParticleMomentumDirection(G4ThreeVector(0.,0.,-1.0));
particleGun->SetParticleEnergy(1.0*GeV);
*/
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PrimaryGeneratorAction::~PrimaryGeneratorAction()
delete particleGun;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
E.3 173
E.3.11. RunAction.cc
#include "RunAction.hh"
#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>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::RunAction(DetectorConstruction* det,
PrimaryGeneratorAction* prim,
HistoManager* histo)
: detector(det), primary(prim), ProcCounter(0), histoManager(histo)
totalEventCount=0;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::~RunAction()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::FillData(const G4String & particleName,
G4double kinEnergy, G4double costheta,
G4double /* phi*/,
G4double longitudinalPolarization)
if (particleName=="gamma")
photonStats.FillData(kinEnergy, costheta, longitudinalPolarization);
else if (particleName=="e-")
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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();
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::EventFinished()
++totalEventCount;
photonStats.EventFinished();
electronStats.EventFinished();
positronStats.EventFinished();
E.3 176
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::ParticleStatistics::ParticleStatistics()
: currentNumber(0),
totalNumber(0), totalNumber2(0),
sumEnergy(0), sumEnergy2(0),
sumPolarization(0), sumPolarization2(0),
sumCosTheta(0), sumCosTheta2(0)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::ParticleStatistics::~ParticleStatistics()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::ParticleStatistics::EventFinished()
totalNumber+=currentNumber;
totalNumber2+=currentNumber*currentNumber;
currentNumber=0;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::ParticleStatistics:: FillData(G4double kinEnergy,
G4double costheta,
G4double longitudinalPolarization)
++currentNumber;
sumEnergy+=kinEnergy;
sumEnergy2+=kinEnergy*kinEnergy;
sumPolarization+=longitudinalPolarization;
sumPolarization2+=longitudinalPolarization*longitudinalPolarization;
sumCosTheta+=costheta;
sumCosTheta2+=costheta*costheta;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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";
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::ParticleStatistics::Clear()
currentNumber=0;
totalNumber=totalNumber2=0;
sumEnergy=sumEnergy2=0;
sumPolarization=sumPolarization2=0;
sumCosTheta=sumCosTheta2=0;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
StepMax::StepMax(const G4String& processName)
: G4VDiscreteProcess(processName),MaxChargedStep(DBL_MAX)
pMess = new StepMaxMessenger(this);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
StepMax::~StepMax() delete pMess;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4bool StepMax::IsApplicable(const G4ParticleDefinition& particle)
return (particle.GetPDGCharge() != 0.);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void StepMax::SetMaxStep(G4double step) MaxChargedStep = step;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4double StepMax::PostStepGetPhysicalInteractionLength(const
G4Track& aTrack,
G4double,
G4ForceCondition* condition )
// condition is set to "Not Forced"
*condition = NotForced;
E.3 179
G4double ProposedStep = DBL_MAX;
if((MaxChargedStep > 0.) &&
(aTrack.GetVolume() != 0) &&
(aTrack.GetVolume()->GetName() != "World"))
ProposedStep = MaxChargedStep;
return ProposedStep;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4VParticleChange* StepMax::PostStepDoIt(const G4Track& aTrack,
const G4Step&)
// do nothing
aParticleChange.Initialize(aTrack);
return &aParticleChange;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
E.3.14. StepMaxMessenger.cc
#include "StepMaxMessenger.hh"
#include "StepMax.hh" #include "G4UIcmdWithADoubleAndUnit.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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");
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
StepMaxMessenger::~StepMaxMessenger()
E.3 180
delete StepMaxCmd;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void StepMaxMessenger::SetNewValue(G4UIcommand* command, G4String
newValue)
if (command == StepMaxCmd)
pStepMax->SetMaxStep(StepMaxCmd->GetNewDoubleValue(newValue));
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
SteppingAction::SteppingAction(DetectorConstruction* det,
PrimaryGeneratorAction* prim, RunAction* RuAct,
HistoManager* Hist)
:detector(det), primary(prim), runAction(RuAct), histoManager(Hist)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
SteppingAction::~SteppingAction()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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";
////cambiado y agregado por mi
G4ThreeVector position = endPoint->GetPosition();
G4double positionX = prePoint->GetPosition().x();
G4double positionY = prePoint->GetPosition().y();
////cambiado y agregado por mi
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);
////modificado por mi
histoManager->
FillHistos(particleName,kinEnergy,costheta,phi,polZ,positionX,positionY);
////modificado por mi
runAction->FillData(particleName,kinEnergy,costheta,phi,polZ);
E.4 182
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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 "ExN01MagneticField.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
#include "G4UImessenger.hh" #include "globals.hh"
class DetectorConstruction; class G4UIdirectory; class
G4UIcmdWithAString; class G4UIcmdWithADoubleAndUnit; class
G4UIcmdWithoutParameter;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class DetectorMessenger: public G4UImessenger
public:
E.4 184
DetectorMessenger(DetectorConstruction* );
~DetectorMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
DetectorConstruction* Detector;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
RunAction* runAction;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
E.4.5. EventActionMessenger.hh
#ifndef EventActionMessenger_h #define EventActionMessenger_h 1
#include "G4UImessenger.hh" #include "globals.hh"
class EventAction; class G4UIdirectory; class G4UIcmdWithAnInteger;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class EventActionMessenger: public G4UImessenger
public:
EventActionMessenger(EventAction*);
~EventActionMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
EventAction* eventAction;
G4UIdirectory* eventDir;
G4UIcmdWithAnInteger* PrintCmd;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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*, G4String);
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
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
namespace AIDA
class IAnalysisFactory;
class ITree;
class IHistogram1D;
/////Mi agregado
class ICloud2D;
/////Mi agregado
class HistoMessenger;
const G4int MaxHisto = 13;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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,
G4double longitudinalPolarization,
/////Mi agregado
G4double posX, G4double posY
/////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;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
E.4.8. HistoMessenger.hh
#ifndef HistoMessenger_h #define HistoMessenger_h 1
#include "G4UImessenger.hh" #include "globals.hh"
E.4 190
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class HistoManager; class G4UIdirectory; class G4UIcommand; class
G4UIcmdWithAString; class G4UIcmdWithAnInteger;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
G4UIcmdWithAnInteger* rmhistoCmd;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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);
void SetMaxStep(G4double);
public:
G4double MaxChargedStep;
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>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class DetectorConstruction; class PrimaryGeneratorAction; class
HistoManager; class G4Run;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class RunAction : public G4UserRunAction
class ParticleStatistics
public:
ParticleStatistics();
~ParticleStatistics();
void EventFinished();
void FillData(G4double kinEnergy, G4double costheta,
G4double longitudinalPolarization);
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,
G4double kinEnergy, G4double costheta, G4double phi,
G4double longitudinalPolarization);
void EventFinished();
private:
DetectorConstruction* detector;
PrimaryGeneratorAction* primary;
ProcessesCount* ProcCounter;
HistoManager* histoManager;
G4int totalEventCount;
ParticleStatistics photonStats;
ParticleStatistics electronStats;
ParticleStatistics positronStats;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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,
G4double previousStepSize,
G4ForceCondition* condition
);
G4VParticleChange* PostStepDoIt(
const G4Track& ,
const G4Step&
);
void SetMaxStep(G4double);
protected:
// it is not needed here !
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
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)
// condition is set to "Not Forced"
*condition = NotForced;
G4double ProposedStep = DBL_MAX;
if((MaxChargedStep > 0.) &&
(aTrack.GetVolume() != 0) &&
(aTrack.GetVolume()->GetName() == "Absorber") &&
(aTrack.GetDynamicParticle()->GetDefinition()->GetPDGCharge() != 0.))
ProposedStep = MaxChargedStep ;
return ProposedStep;
inline G4VParticleChange* StepCut::PostStepDoIt(
const G4Track& aTrack,
const G4Step&
)
// do nothing
aParticleChange.Initialize(aTrack);
return &aParticleChange;
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;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
E.4.15. StepMaxMessenger.hh
#ifndef StepMaxMessenger_h #define StepMaxMessenger_h 1
#include "G4UImessenger.hh" #include "globals.hh"
class StepMax; class G4UIcmdWithADoubleAndUnit;
E.4 199
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class StepMaxMessenger: public G4UImessenger
public:
StepMaxMessenger(StepMax*);
~StepMaxMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
StepMax* pStepMax;
G4UIcmdWithADoubleAndUnit* StepMaxCmd;
;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
E.4.16. SteppingAction.hh
#ifndef SteppingAction_h #define SteppingAction_h 1
#include "G4UserSteppingAction.hh" #include "globals.hh"
class DetectorConstruction; class PrimaryGeneratorAction; class
RunAction; class HistoManager;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class SteppingAction : public G4UserSteppingAction
public:
SteppingAction(DetectorConstruction*, PrimaryGeneratorAction*, RunAction*,
HistoManager*);
~SteppingAction();
void UserSteppingAction(const G4Step*);
private:
DetectorConstruction* detector;
PrimaryGeneratorAction* primary;
RunAction* runAction;
HistoManager* histoManager;
;
E.4 200
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#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