Documente Academic
Documente Profesional
Documente Cultură
GEANT4
Ticse Torres Royer
Dávila Aguilar Houston
Diciembre-2009
INTRODUCCIÓN
La Física Nuclear y la Investigación de altas energías tal como la conocemos hoy en día no sería
posible sin las simulaciones. La producción masiva de muestras de eventos similares a los
previstos en los experimentos reales es una parte integral del proceso de diseño, construcción, y la
comisión de la muy complejo de aceleradores y detectores de partículas utilizados en
experimentación y la física nuclear.
Las simulaciones son también esenciales para desarrollar las herramientas de software, el estrés,
la infraestructura informática de prueba, y analizar los datos recogidos por los experimentos.
GEANT4
GEANT4 es un conjunto de herramientas para la simulación de partículas elementales y los
núcleos que al pasar por un material, interaccionan con los núcleos de dicho material. En él se
describe el seguimiento de las partículas a través de una geometría compuesta de diferentes los
materiales, sus interacciones con los electrones y los núcleos que se encuentran y la creación de
otras partículas en estas interacciones. GEANT4 es completamente una re-ingeniería de objetos,
sucesor orientada a Geant3, y un proyecto pionero para adaptarse con éxito las técnicas modernas
de ingeniería de software a la simulación del detector de partículas y física nuclear. Es un conjunto
de herramientas, está diseñada para el modelo de todos los elementos asociados con la
simulación del detector: la geometría del sistema, los materiales involucrados, las partículas de
fundamental interés, la generación de eventos primarios, el seguimiento de las partículas de
a través de materiales y campos electromagnéticos, los procesos que rigen la física de partículas
interacciones, la respuesta de los componentes del detector, sensibilidad, la generación de datos
de eventos, almacenamiento de eventos y pistas, la visualización del detector y trayectorias de las
partículas, y la captura y análisis de datos de simulación en los diferentes niveles de detalle y el
refinamiento.
GEANT4 ofrece importantes ventajas sobre otros paquetes de simulación, tales como MCNP2,
EGS3, o de Fluka4, también utilizado en el HEP y comunidades de la física nuclear. Estos incluyen
la capacidad de manejar las geometrías más complejas y realistas, la cobertura de la mayoría de la
física conocida los procesos para todo tipo de partículas elementales y los núcleos necesarios para
la simulación del detector, la disponibilidad de varios modelos de la física de alternativas que
permitan al usuario elegir entre ellos basados en sus necesidades de precisión y velocidad,
facilidad de adaptación a los marcos de los usuarios de software, y extensión fácil por los usuarios
de acuerdo a sus necesidades particulares.
Instalaleremos la versiòn geant4.9.2.p01 para Linux en este caso sobre Ubuntu 9.04
GCC es un compilador integrado del proyecto GNU para C, C++, Objective C y Fortran; es capaz de
recibir un programa fuente en cualquiera de estos lenguajes y generar un programa ejecutable
binario en el lenguaje de la máquina donde ha de correr. La sigla GCC significa "GNU Compiler
Collection". Originalmente significaba "GNU C Compiler"; todavía se usa GCC para designar una
compilación en C. G++ refiere a una compilación en C++.
Verificar que versiòn de gcc tiene para ello escriba en el terminal: gcc -v en el terminal te
indicara si esta o no instalado alguna versiòn gcc, si no esta instalado se tendra que intalar
alguna versiòn recomendados:
C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup.
La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos
que permitan la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes
orientados a objetos, el C++ es un lenguaje híbrido.
Posteriormente se añadieron facilidades de programación genérica, que se sumó a los otros dos
paradigmas que ya estaban admitidos (programación estructurada y la programación orientada a
objetos). Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma.
Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los
fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.
Una particularidad del C++ es la posibilidad de redefinir los operadores (sobrecarga de operadores),
y de poder crear nuevos tipos que se comporten como tipos fundamentales.
El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado por
primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En
C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.
OpenGL (Open Graphics Library) es una especificación estándar que define una API multilenguaje
y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. La interfaz consiste en
más de 250 funciones diferentes que pueden usarse para dibujar escenas tridimensionales
complejas a partir de primitivas geométricas simples, tales como puntos, líneas y triángulos. Fue
1
desarrollada originalmente por Silicon Graphics Inc. (SGI) en 1992 y se usa ampliamente en CAD,
realidad virtual, representación científica, visualización de información y simulación de vuelo.
También se usa en desarrollo de videojuegos, donde compite con Direct3D en plataformas Microsoft
Windows.
Fundamentalmente OpenGL es una especificación, es decir, un documento que describe un conjunto
de funciones y el comportamiento exacto que deben tener. Partiendo de ella, los fabricantes de
hardware crean implementaciones, que son bibliotecas de funciones que se ajustan a los requisitos
de la especificación, utilizando aceleración hardware cuando es posible. Dichas implementaciones
deben superar unos tests de conformidad para que sus fabricantes puedan calificar su
implementación como conforme a OpenGL y para poder usar el logotipo oficial de OpenGL.
En este caso usaremos el visor OpenGL para lo cual se tendra que instalar las librerias necesarias
para su correcto funcionamiento.
Recomendaciones: se sugiere que se instale con sumo cuidado dichas librerias ya que algunas
desinstalan otras las cuales podrian producir algùn error en el sistema operativo por lo cual no
instalar dichas librerias.
Si desea pude utilizar otros visores como es el caso de VRML la cual conyeva a instalar sus
respectivas librerias. Recomendación no utilice dos visores o mas ya que podria generar conflictos.
PASO Nº4 (CLHEP)
Crear una carpeta con el nombre CLHEP. Luego descargue el archivo clhep-2.0.4.2.tgz de
3.4 Mb que lo puede obtener de la siguiente dirección:
http://proj-clhep.web.cern.ch/proj-clhep/DISTRIBUTION/distributions/clhep2.0.4.2.tgz
Una vez descargado el archivo descomprima en la carpeta CLHEP antes creada. Obtendrá
la siguiente carpeta 2.0.4.2.
Finaliza con:
Luego de obtenido lo anterior, escriba en el terminal: make
make[1]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP/Units‘
make[2]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi//CLHEP/2.0.4.2/CLHEP/Units/Units'
make all-am
make[3]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi//CLHEP/2.0.4.2/CLHEP/Units/Units'
make[3]:Leavingdirectory`/afs/slac.stanford.edu/home/hovi//CLHEP/2.0.4.2/CLHEP/Units/Units'
make[2]:Leavingdirectory`/afs/slac.stanford.edu/home/hovi//CLHEP/2.0.4.2/CLHEP/Units/Units'
Termina con:
make[1]:Enteringdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP' ./build-
clheplib Units Vector Evaluator GenericFunctions Geometry Random Matrix RandomObjects
RefCount Cast Exceptions rm -f libCLHEP-2.0.4.2.a liblist=`./getObjectList -static Units
Vector Evaluator GenericFunctions Geometry Random Matrix RandomObjects RefCount
Cast Exceptions`; \ ar cru libCLHEP-2.0.4.2.a $liblist; ranlib libCLHEP-2.0.4.2.a rm -f
libCLHEP-2.0.4.2.so liblist=`./getObjectList -shared Units Vector Evaluator GenericFunctions
Geometry Random Matrix RandomObjects RefCount Cast Exceptions`; \ g++ -O -ansi -
pedantic -Wall -D_GNU_SOURCE -g -O2 -o libCLHEP-2.0.4.2.so -shared -Wl,-
soname,libCLHEP-2.0.4.2.so $liblist -o libCLHEP-2.0.4.2.so ./build-header
make[1]:Leavingdirectory`/afs/slac.stanford.edu/home/hovi/CLHEP/2.0.4.2/CLHEP'
Termina con:
NOTA: Si esta todo correcto en la carpeta CLHEP aparecerá dos directorios con los
nombres include y lib.
Crear una carpeta con el nombre geant4. Luego descargue el archivo geant4.9.2.p01tgz
de 18 Mb que lo puede obtener de la siguiente dirección:
http://geant4.web.cern.ch/geant4/support/source/geant4.9.2.p01.tar.gz
una vez descargado el archivo descomprima en la carpeta geant4, antes creada. Obtendrá
la siguiente carpeta geant4.9.2.p01
http://geant4.web.cern.ch/geant4/support/source/G4EMLOW.6.2.tar.gz
PASO Nº7
./Configure –build
luego vuelva a escribir en el terminal: ./Configure –install
(genera los scrips: env.csh . env.sh)
Ahora procedemos a ejecutar uno de los ejemplos para ello realizamos lo siguiente:
Termina en:
Aparecerá un mensaje
Aparecerá un mensaje
Aparecerá un mensaje
Aparecerá un mensaje
Digitamos un comando tal como se ve en la imagen para girar y ver mejor, obteniendo
Se obtendrá
Otro angulo
Bueno eso es todo referente a la instalación del GEANT4 con su respectivo ejemplo de prueba
para ver si todo a sido instalado de forma correcta.
Por algún motivo no se lograra obtener lo antes expuesto se sugiere visitar las siguientes páginas
donde se presentan otras alternativas de instalación.
http://geant4.kek.jp/g4users/g4space5/
http://www-geant4.kek.jp/g4users/g4tut07/install-win.html
Geant4 - Aplicación
http://conferences.fnal.gov/g4tutorial/
1. Geometría.
Antes de comenzar describimos algunas características del ejemplo escogido.
Decaimiento.
Transporte en un campo.
Materiales.
Es decir solo tenemos el primer brazo del espectrómetro. Que consiste en una caja con
aire, Hodoscope (15 centelladores verticales) y la cámara de deriva (5 capas de gas Argón
con una placa en el centro de cada capa).
Parte de A01MagneticField.cc
void A01MagneticField::GetFieldValue(const double Point[3],double *Bfield) const
{
Bfield[0] = 0.;
Bfield[2] = 0.;
if(std::abs(Point[1])<ymax && (sqr(Point[0])+sqr(Point[2]))<rmax_sq)
{ Bfield[1] = By; }
else
{ Bfield[1] = 0.; }
}
Parte A01Detectorconstruction.cc
#include "G4FieldManager.hh"
#include "G4TransportationManager.hh"
#include "A01MagneticField.hh“
A01DetectorConstruction::A01DetectorConstruction()
: air(0), argonGas(0), scintillator(0),
…
{ messenger = new A01DetectorConstMessenger(this);
magneticField = new A01MagneticField();
…
A01DetectorConstruction::~A01DetectorConstruction()
{ delete magneticField;
delete armRotation;
...
// campo magnetico
static G4bool fieldIsInitialized = false;
if(!fieldIsInitialized)
{ G4FieldManager* fieldMgr =
G4TransportationManager::GetTransportationManager()->GetFieldManager();
fieldMgr->SetDetectorField(magneticField);
fieldMgr->CreateChordFinder(magneticField);
fieldIsInitialized = true;
}
Parte A01Detectorconstruction.cc
Parte A01Detectorconstruction.cc
parte de A01CellParameterisation.cc
A01CellParameterisation::A01CellParameterisation()
{
for(int copyNo=0;copyNo<80;copyNo++)
{ G4int column = copyNo / 4;
G4int row = copyNo % 4;
xCell[copyNo] = (column-9)*15.*cm - 7.5*cm;
yCell[copyNo] = (row-1)*15*cm - 7.5*cm;
}
}
A01CellParameterisation::~A01CellParameterisation()
{;}
void A01CellParameterisation::ComputeTransformation
(const G4int copyNo,G4VPhysicalVolume *physVol) const
{
physVol->SetTranslation(G4ThreeVector(xCell[copyNo],yCell[copyNo],0.));
}
Agregamos el calorímetro Hadrónico.
Sándwiches de plomo y centellador de 30cm de ancho, 30cm de altura y 5cm de
espesor. Colocados en un arreglo de 3m de ancho, 60cm de altura y 1m de
espesor.
Parte A01Detectorconstruction.cc
Los procesos físicos describen como interactúan las partículas con el material tenemos 7
categorías principales de procesos: electromagnetico, hadrónico, decaimiento, fotolepton-
hadron, ópticos, parametrización y de transporte.
Cada proceso tiene dos grupos de métodos que desempeñan un papel importante en el
seguimiento, GetPhysicalInteractionLength (GPIL) y DoIt. El método de GPIL da la longitud
del paso desde el punto espacio – tiempo actual a el punto espacio-tiempo siguiente .Esto
se hace mediante el cálculo de la probabilidad de interacción basado en la información la
sección transversal del proceso.. Al final de este paso, el método DoIt debe invocarse El
método de DoIt implementa los detalles de la interacción, el cambio de energía de la
partícula, el impulso, dirección y posición, y la producción secundaria si es necesario.
Estos cambios se registran como objetos G4VParticleChange
Geantino.
Esta partícula fue inventado para la simulación en Geant4, no interactúa con la
materia , solo es necesario el proceso de transporte.
Positrón.
Para incluir la física electromagnética , incluimos A01EMPhysics.hh en
A01EMPhysicsList.
Se desvía en el campo y produce una lluvia de cargas en el calorímetro EM.
Procesos: dispersión múltiple, bremsstrahlung e, ionización ,aniquilación e+.
Muones.
Incluir en A01EMPhysicsList.cc , A01MuonPhysics.hh
Ioniza el aire produciendo cargas negativas(rojo)
Procesos: dispersión múltiple , bremsstrahlung mu, ionización de mu, producción
de pares e + e- por muones
Pion.
Agregamos física hidrómica (A01HadronPhysics.hh y A01HadronPhysics.cc)
El pion se desintegra en muon y neutrino en la primera cámara de deriva.
Procesos: Hadron elástica ,Hadron inelástica ,captura y fisión de neutrones
,aniquilación en reposo para anti-protones y anti-neutrones , scattering múltiple
para hadrones cargados, ionización de hadrones cargados .
3. Sensibilidad.
Hit es la interacción física instantánea en la trayectoria de la partícula o
acumulación de interacciones en la región sensible del detector.
La región sensible del detector crea hits usando la información dado en el objeto
G4Step y almacenados en G4Event al final de un evento.
El usuario define su clase hit derivado de G4VHit, pudiendo almacenar varios tipos
de información en esta clase como: posición y tiempo de paso, momento y energía
de la trayectoria, energia de deposición, información geométrica y combinaciones
de estos.
Los objetos de una clase hit deben ser almacenados en una colección, el cual es
una instancia de G4THitsCollection template class.
La colección hits son accesibles a través de G4Event al final de un evento, para
ser usado en el análisis del evento, y a través de G4SDManager durante el
proceso del evento, que se utiliza para el filtrado del evento.
Parte de A01DetectorConstruction.cc
G4VPhysicalVolume* A01DetectorConstruction::Construct()
{
//
G4VSensitiveDetector* hodoscope1;
G4VSensitiveDetector* chamber1;
G4VSensitiveDetector* hodoscope2;
G4VSensitiveDetector* camara2;
G4SDManager* SDman = G4SDManager::GetSDMpointer();
G4String SDname;
hodoscope1 = new A01Hodoscope(SDname="/hodoscope1");
SDman->AddNewDetector(hodoscope1);
hodoscope1Logical->SetSensitiveDetector(hodoscope1);
Parte de A01EvenAction.cc
A01EventAction::A01EventAction()
{
G4String colName;
G4SDManager* SDman = G4SDManager::GetSDMpointer();
HHC1ID = SDman->GetCollectionID(colName="hodoscope1/hodoscopeColl");
DHC1ID = SDman->GetCollectionID(colName="chamber1/driftChamberColl");
//colocando ID
HHC2ID = SDman->GetCollectionID(colName="hodoscope2/hodoscopeColl");
DHC2ID = SDman->GetCollectionID(colName="camara2/driftChamberColl");
void A01EventAction::EndOfEventAction(const G4Event* evt)
{
G4HCofThisEvent * HCE = evt->GetHCofThisEvent();
A01HodoscopeHitsCollection* HHC1 = 0;
A01DriftChamberHitsCollection* DHC1 = 0;
//...
A01HodoscopeHitsCollection* HHC2 = 0;
A01DriftChamberHitsCollection* DHC2 = 0;
//....
A01EmCalorimeterHitsCollection* ECHC = 0;
A01HadCalorimeterHitsCollection* HCHC = 0;
if(HCE)
{
HHC1 = (A01HodoscopeHitsCollection*)(HCE->GetHC(HHC1ID));
DHC1 = (A01DriftChamberHitsCollection*)(HCE->GetHC(DHC1ID));
//...
HHC2 = (A01HodoscopeHitsCollection*)(HCE->GetHC(HHC2ID));
DHC2 = (A01DriftChamberHitsCollection*)(HCE->GetHC(DHC2ID));
//....
ECHC = (A01EmCalorimeterHitsCollection*)(HCE->GetHC(ECHCID));
HCHC = (A01HadCalorimeterHitsCollection*)(HCE->GetHC(HCHCID));
}
...
//
if(HHC2)
{ int n_hit = HHC2->entries();
G4cout << "Hodoscope 2 tiene " << n_hit << " colisiones." << G4endl;
for(int i1=0;i1<n_hit;i1++)
{
A01HodoscopeHit* aHit = (*HHC2)[i1];
aHit->Print();
}
}
}
//
if(DHC2)
{
int n_hit = DHC2->entries();
G4cout << "Camara de deriva 2 tiene " << n_hit << " colisiones." << G4endl;
for(int i2=0;i2<5;i2++)
{
for(int i1=0;i1<n_hit;i1++)
{
A01DriftChamberHit* aHit = (*DHC2)[i1];
if(aHit->GetLayerID()==i2) aHit->Print();
}
}
}
Salida.
>>> Event 0 >>> Simulation truth : e+ (-4.615962429507,0,989.29283496844)
Hodoscope 1 has 1 hits.
Hodoscope[7] 4.9868571910584 (nsec)
Hodoscope 2 tiene 1 colisiones.
Hodoscope[8] 43.07777699026 (nsec)
Drift Chamber 1 has 6 hits.
Layer[0] : time 6.6711038083754 (nsec) --- local (x,y) -12.964912979212, -0.039498654249376
Layer[1] : time 8.3390095958199 (nsec) --- local (x,y) -17.974093214733, -0.68236328588736
Layer[2] : time 10.006909835187 (nsec) --- local (x,y) -22.798176055634, -1.4412423578075
Layer[3] : time 11.674807992901 (nsec) --- local (x,y) -27.5507927848, -2.2321515445323
Layer[3] : time 12.332190636356 (nsec) --- local (x,y) -6.0281819661482, -86.553137480673
Layer[4] : time 13.342699048469 (nsec) --- local (x,y) -32.01375154174, -3.297089404578
Camara de deriva 2 tiene 5 colisiones.
Layer[0] : time 34.737886998822 (nsec) --- local (x,y) -224.55971729671, -23.354142901273
Layer[1] : time 36.409114104763 (nsec) --- local (x,y) -256.50456338376, -24.689009720259
Layer[2] : time 38.080321993001 (nsec) --- local (x,y) -288.35526777196, -26.116257650382
Layer[3] : time 39.751583993649 (nsec) --- local (x,y) -320.45799915737, -27.582919723848
Layer[4] : time 41.422867626714 (nsec) --- local (x,y) -352.647703604, -29.33252167976
Calorímetro EM y Hadrónico.
Parte de A01HadCalorimeter.cc
A01HadCalorimeter::A01HadCalorimeter(G4String name)
:G4VSensitiveDetector(name)
{
//definimos coleccion de hits
G4String HCname;
collectionName.insert(HCname="HadCalorimeterColl");
HCID = -1;
}
void A01HadCalorimeter::Initialize(G4HCofThisEvent*HCE)
{ //inicializacion
hitsCollection = new A01HadCalorimeterHitsCollection
(SensitiveDetectorName,collectionName[0]);
if(HCID<0)
{ HCID = G4SDManager::GetSDMpointer()->GetCollectionID(hitsCollection); }
HCE->AddHitsCollection(HCID,hitsCollection);
// llenado de las colisiones del calorimetro con energia cero.
for(int iColumn=0;iColumn<10;iColumn++)
for(int iRow=0;iRow<2;iRow++)
{
A01HadCalorimeterHit* aHit = new A01HadCalorimeterHit();
hitsCollection->insert( aHit );
}
}
G4bool A01HadCalorimeter::ProcessHits(G4Step*aStep,G4TouchableHistory* )
{//....
G4double edep = aStep->GetTotalEnergyDeposit();
if(edep==0.) return true;
G4StepPoint* preStepPoint = aStep->GetPreStepPoint();
G4TouchableHistory* theTouchable
= (G4TouchableHistory*)(preStepPoint->GetTouchable());
G4VPhysicalVolume* theCellPhysical = theTouchable->GetVolume(2);
G4int rowNo = theCellPhysical->GetCopyNo();
G4VPhysicalVolume* theColumnPhysical = theTouchable->GetVolume(3);
G4int columnNo = theColumnPhysical->GetCopyNo();
G4int hitID = 2*columnNo+rowNo;
A01HadCalorimeterHit* aHit = (*hitsCollection)[hitID];
// agregar energia de depsicion
aHit->AddEdep(edep);
// check if it is first touch....
if(aHit->GetColumnID()<0)
{aHit->SetColumnID(columnNo);
aHit->SetRowID(rowNo);
G4int depth = theTouchable->GetHistory()->GetDepth();
G4AffineTransform aTrans = theTouchable->GetHistory()->GetTransform(depth-
2);
aTrans.Invert();
aHit->SetRot(aTrans.NetRotation());
aHit->SetPos(aTrans.NetTranslation());
} return true;
}
Parte de A01DetectorConstruction.cc
G4VPhysicalVolume* A01DetectorConstruction::Construct()
{// All managed (deleted) by SDManager
G4VSensitiveDetector* hodoscope1;
G4VSensitiveDetector* chamber1;
G4VSensitiveDetector* hodoscope2;
G4VSensitiveDetector* camara2;
G4VSensitiveDetector* calorimetroEM;
G4VSensitiveDetector* calorimetroHad;
ConstructMaterials();
...
//sensibilidad del calorimetro EM y Had
calorimetroEM = new A01EmCalorimeter(SDname="/calorimetroEM");
SDman->AddNewDetector(calorimetroEM);
cellLogical->SetSensitiveDetector(calorimetroEM);
calorimetroHad = new A01HadCalorimeter(SDname="/calorimetroHad");
SDman->AddNewDetector(calorimetroHad);
HadCalScintiLogical->SetSensitiveDetector(calorimetroHad);
Parte de A01EvenAction.cc
void A01EventAction::EndOfEventAction(const G4Event* evt)
{G4HCofThisEvent * HCE = evt->GetHCofThisEvent();
A01HodoscopeHitsCollection* HHC1 = 0;
A01DriftChamberHitsCollection* DHC1 = 0;
A01HodoscopeHitsCollection* HHC2 = 0;
A01DriftChamberHitsCollection* DHC2 = 0;
//....
A01EmCalorimeterHitsCollection* ECHC = 0;
A01HadCalorimeterHitsCollection* HCHC = 0;
if(HCE)
{HHC1 = (A01HodoscopeHitsCollection*)(HCE->GetHC(HHC1ID));
DHC1 = (A01DriftChamberHitsCollection*)(HCE->GetHC(DHC1ID));
HHC2 = (A01HodoscopeHitsCollection*)(HCE->GetHC(HHC2ID));
DHC2 = (A01DriftChamberHitsCollection*)(HCE->GetHC(DHC2ID));
//....
ECHC = (A01EmCalorimeterHitsCollection*)(HCE->GetHC(ECHCID));
HCHC = (A01HadCalorimeterHitsCollection*)(HCE->GetHC(HCHCID));
}
if(ECHC)
{ int iHit = 0;
double totalE = 0.;
for(int i1=0;i1<80;i1++)
{A01EmCalorimeterHit* aHit = (*ECHC)[i1];
double eDep = aHit->GetEdep();
if(eDep>0.)
{iHit++;
totalE += eDep; }
}
G4cout << "Calorimetro EM tiene " << iHit << " colisiones. Total de Edep es " <<
totalE/MeV << " (MeV)" << G4endl;
}
if(HCHC)
{int iHit = 0;
double totalE = 0.;
for(int i1=0;i1<20;i1++)
{A01HadCalorimeterHit* aHit = (*HCHC)[i1];
double eDep = aHit->GetEdep();
if(eDep>0.)
{ iHit++;
totalE += eDep; }
}
G4cout << "Calorimetro Hadronico tiene " << iHit << " colisiones. Total de Edep
es "<< totalE/MeV << " (MeV)" << G4endl; }
}
Salida.
2. http://conferences.fnal.gov/g4tutorial/
3. http://geant4.web.cern.ch/geant4/UserDocumentation/UsersGuides/ForApplicationDevelope
r/html/index.html .