Requisitos

  • En este caso se uso Ubuntu 20.04, puedes usar este o superior
  • Conexión a Internet
  • Terminal (Ctrl + Alt + T)

Paso 1: Instalar Anaconda en Ubuntu

1.1 Descargar Anaconda (versión estable)

cd ~/Downloads
wget https://repo.anaconda.com/archive/Anaconda3-2024.02-1-Linux-x86_64.sh

1.2 Ejecutar el instalador

bash Anaconda3-2024.02-1-Linux-x86_64.sh

Presiona Enter para aceptar la licencia, y responde yes cuando pregunte si quieres modificar .bashrc.

1.3 Activar conda

Después de la instalación:

source ~/.bashrc

Verifica:

conda --version

Paso 2: Crear un entorno para ROOT y Geant4

2.1 Establecer prioridad de canales

conda config --set channel_priority strict

2.2 Crear el entorno

conda create -n geant-root-env -c conda-forge root

2.3 Activarlo

conda activate geant-root-env

Paso 3: Instalar Geant4 desde Conda

Con el entorno activo:

conda install -c conda-forge geant4

Verificar que funciona

Ver ROOT

root

Debe mostrar la bienvenida de ROOT. Sal con .q o Ctrl+D.

Ver Geant4

geant4-config --version

Debe mostrar 11.3.2 u otra versión reciente.

Paso 4: Probar visualización en Geant4

4.1 Código de ejemplo (main.cc)

Crea un archivo main.cc con el siguiente contenido:

#include "G4RunManager.hh"
#include "G4UImanager.hh"
#include "G4NistManager.hh"
#include "G4Box.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4SystemOfUnits.hh"
#include "G4VUserDetectorConstruction.hh"
#include "FTFP_BERT.hh"
#include "G4UIExecutive.hh"
#include "G4VisExecutive.hh"

class MyDetectorConstruction : public G4VUserDetectorConstruction {
public:
G4VPhysicalVolume* Construct() override {
G4NistManager* nist = G4NistManager::Instance();
G4Material* air = nist->FindOrBuildMaterial("G4_AIR");

G4Box* solidWorld = new G4Box("World", 1.*m, 1.*m, 1.*m);
G4LogicalVolume* logicWorld = new G4LogicalVolume(solidWorld, air, "World");
return new G4PVPlacement(nullptr, {}, logicWorld, "World", nullptr, false, 0, true);
}
};

int main(int argc, char** argv) {
G4UIExecutive* ui = new G4UIExecutive(argc, argv);
auto runManager = new G4RunManager();
runManager->SetUserInitialization(new MyDetectorConstruction());
runManager->SetUserInitialization(new FTFP_BERT());
G4VisManager* visManager = new G4VisExecutive();
visManager->Initialize();
runManager->Initialize();

G4UImanager* UImanager = G4UImanager::GetUIpointer();
UImanager->ApplyCommand("/vis/open OGL");
UImanager->ApplyCommand("/vis/drawVolume");
UImanager->ApplyCommand("/vis/viewer/setViewpointThetaPhi 90 0");
UImanager->ApplyCommand("/vis/scene/add/axes 0 0 0 1 m");

ui->SessionStart();

delete ui;
delete visManager;
delete runManager;
return 0;
}

4.2 Compilar

g++ main.cc -o testG4 $(geant4-config --cflags --libs) -std=c++17

4.3 Ejecutar

./testG4

Deberías ver una ventana 3D con el volumen del mundo.

Extras útiles

Exportar tu entorno Conda a un .yml:

conda env export > geant-root-env.yml

Y puedes recrearlo así:

conda env create -f geant-root-env.yml

Compilación de Archivos de Ejemplos

Proceso de Compilación y Ejecución para Geant4 y ROOT

El proceso correcto para compilar y ejecutar tu ejemplo de Geant4 en un entorno Conda, asumiendo que ya tienes instaladas las bibliotecas necesarias (como Geant4, ROOT, y CMake), es el siguiente:

  1. Crea un directorio de compilación: Es una buena práctica crear un directorio separado para los archivos de compilación, fuera del directorio del código fuente.
mkdir build
cd build
  1. Configura el proyecto con CMake: Desde el directorio build, usa cmake para configurar la compilación. El punto .. le dice a CMake que busque el archivo CMakeLists.txt en el directorio padre.
cmake ..
  1. Compila el proyecto: Una vez que CMake ha configurado todo, usa el comando make para compilar el código fuente. Esto creará un ejecutable.
make
  1. Ejecuta el programa: Después de compilar, el ejecutable se creará en tu directorio build (o en un subdirectorio, dependiendo del CMakeLists.txt). El nombre del ejecutable suele ser el mismo que el nombre del directorio del ejemplo, en este caso exampleB1.
./exampleB1