Geant4-Geometria

=1. La Clase UserDetectorConstruction= toc Se trata de la clase necesaria definida por el usuario para generar la geometría del sistema a simular: cristales centelladores, fotomultiplicadores, calorímetros, etc. Se incluye también en el archivo Main por medio de la clase G4RunManager. La clase principal en la que se construye la geometría (e.g. $G4INSTALL/examples/novice/N02/src/N02DetectorConstruction.cc) es en la parte: code G4VPhysicalVolume* N02DetectorConstruction::Construct { ... // Aquí se definen los materiales, sólidos, detectores sensibles, si existe // algún campo magnético, etc.

return World_phys;

} code En el código anterior es importante retornar el volumen físico del world (i.e. el volumen principal que contiene toda la configuración geométrica)

=2. Definición de elementos y materiales=

2.1 Isótopos
A partir de isótopos se pueden crear elementos, que darán paso a los materiales. Tal material es construido también a partir de moléculas, mezclas o compuestos A manera de ejemplo, se construye un par de isótopos (el código va dentro de Construct) code G4VPhysicalVolume* UserDetectorConstruction::Construct { ...  G4double A, Z;  G4int n_elementos; // Forma general: G4Isotope(Nombre, NAtomico, NElementos, NMasico); G4Isotope* U235 = new G4Isotope("U235", Z=92,                          n_elementos=235, A=235.01*g/mole); G4Isotope* U238 = new G4Isotope("U238", Z=92,                          n_elementos=238, A=238.03*g/mole); ...  return world_phys; // O como se llame el volumen físico } code
 * 1) include "G4Isotope.hh"

2.2 Elementos
code format="cpp" { ...  // Se definen Oxígeno e Hidrógeno G4double A, Z;

// Forma general: G4Element(Nombre, Simbolo, NAtomico, NMasico) G4Element* O = new G4Element("Oxigeno", "O", Z=8, A=16.0*g/mole); G4Element* H = new G4Element("Hidrogeno", "H", Z=1, A=1.01*g/mole); ... } code

2.3.1 Forma simple.
La manera más simple de definir un material, es teniendo en cuenta a los materiales que están hechos de un solo elemento. Considérese material puro. code format="cpp" { ...  // Material hecho de un solo elemento G4double Densidad = 2.7*g/cm3; G4double A = 26.98*g/mole; G4double Z = 13;
 * 1) include "G4Material.hh"

// Forma general: G4Material(Nombre, NAtomico, NMasico, Densidad);

G4Material* Aluminio = new G4Material("Aluminio", Z, A, Densidad); ... } code

2.3.2 Material tipo molécula
A partir de moléculas, también puede formarse un material; por ejemplo el agua: code format="cpp" .. { ... // Tome el código en donde se han definido los elementos hidrógeno y oxigeno .. // Forma general: G4Material(Nombre, Densidad, Nelementos) //               Nombre->AddElement(Elemento, NumeroDeAtomos) G4Material* H2O = new G4Material("Agua", Densidad, Nelementos); H2O->AddElement(H, 2); H2O->AddElement(O, 1); ... } code
 * 1) include "G4Material.hh"

2.3.3 Material via compuestos
Se toma en cuenta la fracción de masa de cada elemento en el material, en lugar del número de elementos. code format="cpp" // Se cambia H2O->AddElement(H,2) por H2O->AddElement(0, 70*perCent); // Suponiendo que existe 70 % de oxígeno en el agua

code

2.3.4 Material via mezclas
En este caso se ocupan elementos y materiales para generar una mezcla: code format="cpp" .. { ..  // Se definen los elementos Si, O, H, C y materiales SiO2, y H2O .. G4Material* AeroGel = new G4Material("AeroGel", 0.2*g/mole,3); AeroGel->AddMaterial(SiO2, 62.5*perCent);     // material AeroGel->AddMaterial(H2O, 37.4*perCent);      // material AeroGel->AddElement(C,    0.1*perCent);       // elemento ... } code

2.3.5 Ejemplo general: Isótopo Material
code format="cpp" ...::Construct { G4Isotope* U235 = new G4Isotope("U235", Z=92,                           n_elementos=235, A=235.01*g/mole); G4Isotope* U238 = new G4Isotope("U238", Z=92,                          n_elementos=238, A=238.03*g/mole); // Se crea uranio G4Element* U = new G4Element("Uranio","U",2); U->AddIsotope(U5, 90*perCent); U->AddIsotope(U8, 10*perCent); ... }
 * 1) include "G4Element.hh"
 * 2) include "G4Isotope.hh"
 * 3) include "G4UnitsTable.hh"

code

2.3.5 Materiales NIST.
Una opción más cómoda, es la de utilizar la base de datos del NIST (National Institute of Standards and Technologies) includida en Geant4. Una lista completa de los materiales definidos se encuentra en $G4INSTALL/source/materials/src/G4NistMaterialBuilder.cc. La metodología es la siguiente: code format="cpp" .. ::Construct { G4Material* AGUA = G4NistManager::Instance->FindOrBuildMaterial("G4_WATER"); G4Material* Cu = G4NistManager::Instance->FindOrBuildMaterial("G4_Cu"); ... return world_phys; } code
 * 1) include "G4NistManager.hh"
 * 2) include "G4Material.hh"

= = =3. Geometría: sólidos, volumen lógico y volumen físico=

3.1 Jerarquías
Antes de comenzar a definir sólidos geométricos, se debe tener en cuenta la jerarquía siguiente:
 * World: Es un tipo de volumen principal que contiene todo el "set up" experimental, se recomienda una forma tipo paralepípedo. Este volumen es el que se retorna en Construct.
 * Daughters: Tipo de volumen contenido dentro de otro volumen de mayor tamaño (mother). El volumen "mother "principal es el "world". Las formas geométricas se explicas más adelante
 * Sensitive detector: Es el sólido dentro del cual se recupera información de las interacciones: energía, posición, tiempo, etc.
 * Target, phantom: Es similar al "sensitive detector", se puede utilizar para medición de dosis en radioterapia por ejemplo.

Se deben definir tres tipos de volúmenes:
 * 1) G4VSolid: forma geométrica.
 * 2) G4LogicalVolume: material, define jerarquía, ¿es volumen sensible?, visualización, ¿exsite campo magnético?
 * 3) G4VPhysicalVolume: posición, réplicas, parametrización, división.

3.3 Volumen sólido
Define la forma geométrica del volumen: esfera, paralepípedo, cilíndro, etc. Se consideran cuatro tipos de sólidos en Geant4: CSG, CSG específicos, Booleanos y BREPS.

3.3.1 Sólido CSG (Constructed Solid Geometry)
El tipo de entidades geométricas son las siguiente: Box, Tubs, Cone, Sphere, Orb, Parallelepiped, Trapezoid, generic trapezoid y torus. Ejemplo: generando sólidos code format="cpp" // Las dimensiones se establecen a la mitad del valor // Box G4double x=10*mm, y=20*mm, z=5*mm; G4Box* box = new G4Box("NombreBox",x/2,y/2,z/2);

// Tubs G4double radio_min=0.4*cm; G4double radio_max=0.6*cm; G4double altura=5*cm; G4double theta_i = 0*degree; G4double theta_f = 45*degree; G4Tubs* tubs = new G4Tubs("NombreTubs",radio_min, radio_max,                                altura, theta_i, theta_f);

code 3.3.2 Sólidos CGS específicos Consta de dos tipos: polycone e hype. code /*Formato general*/

G4Polycone* pol = new G4Polycone( const G4String& nombre,                                 G4double phi_inicial,                                  G4double phi_total,                                  G4double Numero_planosZ,                                  const G4double PlanoZ[],                                  const G4double rInterno[],                                  const G4double rExterno[])

G4Hype* hype = new G4Hype( const G4String& nombre,                          G4double RadioInterno,                           G4double RadioExterno,                           G4double EstereoInterno,                           G4double EstereoExterno,                           G4double AlturaZ/2) code



3.3 Volumen lógico
Los sólidos son entidades geométricas definidas: esfera, paralepípedo, etc. O sólidos ensamblados o booleanos. Los volúmenes lógicos, permiten la tribución de propiedades físicas al sólido, como: el tipo de material, si tiene campo magnético o si será el detector. La manera de definirlo es la siguiente: code G4LogicalVolume* VolumenLogico = new G4LogicalVolume(solido,                               material,                                nombre,                                campo Magnético,                                SensitiveDetector,                                límites geométricos); code
 * Nota: Cualquier otro tipo de modificación al sólido: posición, réplicas, etc., serán definidas sobre el volumen lógico.**

3.2 Volumen Físico
Contiene información acerca de la posición con respecto al volumen madre (G4PVPlacement), réplicas del sólido (G4PVReplica, G4PVParameterised) y rotación del solido con respecto a algún o algunos ejes.

3.2.1 G4PVPlacement
Posición (G4ThreeVector(x,y,z) y rotación (G4RotationMatrix) con respecto al volumen madre. También se pueden copiar sólidos, incrementando el número de répica (último argumento G4int ) code format="cpp" G4VPhysicalVolume* volumenfisico = new G4PVPlacement( // puedeser G4PVReplica, G4PVParameterised Rotacion, // G4ThreeVector Posicion, // G4ThreeVector VolumenLogico, // G4LogicalVolume del solido a modificar VolumenLogicoMadre, // G4LogicalVolume del solido que contiene a nuestro volumen Numero de replica) // G4int Número de réplica code

3.2.2 G4PVReplica
Copia los sólidos con respecto a un eje cartesiano o polar determinado por el usuario (kXAxis, kYAxis, kZAxis, krho o kphi), conservando el centro del total de cópias en el origen del volumen madre. E.g. si copiamos 5 veces un G4Box, la copia número 3 estará centrada en el origen del volumen madre: code format="cpp" new G4PVReplica(Nombre, //G4String               VolLogSolido,  // G4LogicalVolume                VolLogMadre,   // G4LogicalVolume                kXAxis,        // kYAxis, kZAxis, krho o kphi                NumeroReplicas, // G4int                DistCentroCentro, // G4double                OffSet);           // G4double code La distancia entre copias es calculada mediante: code format="cpp" // para i = 0,...,NReplica - 1 -Ancho * (NReplica - 1) * 0.5 + i * Ancho; // i-ésima copia

code

=4. Un ejemplo en concreto= Vamos a crear un arreglo de 20x20 cubos de agua de 2x2x10mm^3. La definición de los materiales, el sólido y los volumenes físico y lógico se realizan dentro de ::Construct {}. El algoritmo quedaría de la siguente manera: code 1. Define elementos con G4Element. 2. Define materiales con G4Material. 3. Define volumen sólido: G4Box, G4Tubs, etc. 3.1 Define volumen lógico: Material, ¿Tiene un campo magnético?, ¿Es un detector? 3.2 Define volumen físico: Posición, réplicas o parametrización. 4. Define atributos de visualización con G4Colour: ¿es visible?, ¿wireframe o solid? 5. return world_phys. code Código: code format="cpp" ...
 * 1) include "G4Element.hh"
 * 2) include "G4Material.hh"
 * 3) include "G4LogicalVolume.hh"
 * 4) include "G4VPhysicalVolume.hh"
 * 5) include "G4PVReplica.hh"
 * 6) include "G4Box.hh"
 * 7) include "G4VisAttributes.hh"
 * 8) include "G4Colour.hh"
 * Contruct {

// 1. Definimos los elementos G4double A, Z, Densidad; G4int nEl; G4Element* O = new G4Element("Oxigeno" , "O" , Z=8,  A = 16.0*g/mole); G4Element* H = new G4Element("Hidrogeno", "H", Z=1,  A = 1.01*g/mole); G4Element* N = new G4Element("Nitrogeno", "N", Z=7,  A = 14*g/mole); G4Element* C = new G4Element("Carbono" , "C" , Z=6,  A = 12.01*g/mole); G4Element* Ar = new G4Element("Argon"  , "Ar", Z=18, A = 39.95*g/mole);

// 2. Definimos los materiales G4Material* Agua = new G4Material("Agua", Densidad = 1*g/cm3, nEl = 2 ); Agua->AddElement(O, 1); Agua->AddElement(H, 2); G4Material* Aire = new G4Material("Aire", Densidad = 1.29*mg/cm3, nEl = 4); Aire->AddElement(N, 75.5268*perCent); Aire->AddElement(O, 23.1781*perCent); Aire->AddElement(Ar, 1.2827*perCent); Aire->AddElement(C, 0.0124*perCent);

// 3. Definimos el solido: world (volumen madre general) G4Box* world = new G4Box("world",1*m,1*m,1*m); G4LogicalVolume world_log = new G4LogicalVolume(world, Aire, "world_log", 0, 0, 0); // Uso de G4PVPlacement G4VPhysicalVolume* world_phys = new G4PVPlacement(0, G4ThreeVector, world_log, 0, false, 0);

// El box de agua. G4Box* pixel = new G4Box("pixel", 1*mm, 1*mm, 5*mm); G4LogicalVolume* pixel_log = new G4LogicalVolume(pixel, Agua, "pixel_log", 0,0,0);

// El box de agua se debe replicar dentro de volumenes auxiliares. Se harán 20 replicas en el eje X // Volumen Auxiliar para réplica en X G4Box* ReplicaX = new G4Box("ReplicaX",20*1*mm, 1*mm, 5*mm); G4LogicalVolume* ReplicaX_log = new G4LogicalVolume(ReplicaX, Aire, "ReplicaX_log",0,0,0); new G4PVPlacement(0,G4ThreeVector,ReplicaX_log,"Replica_phys",world_log,0,0,0); // Uso de G4PVReplica en X new G4PVReplica("Replica", pixel_log, ReplicaX_log, kXAxis, 20, 2*mm, 0);

return world_phys; }

code

.