1
cmake_minimum_required(VERSION 3.10)
2
project(SimpleG4)
3

4
# Busca Geant4 con visualización
5
find_package(Geant4 REQUIRED ui_all vis_all)
6
include(${Geant4_USE_FILE})
7

8
# ROOT (opcional)
9
find_package(ROOT)
10
if(ROOT_FOUND)
11
    include(${ROOT_USE_FILE})
12
    add_definitions(-DWITH_ROOT)
13
endif()
14

15
# Fuentes y cabeceras
16
file(GLOB sources ${PROJECT_SOURCE_DIR}/src/*.cc)
17
file(GLOB headers ${PROJECT_SOURCE_DIR}/include/*.hh)
18

19
# Crea ejecutable
20
add_executable(simpleG4 main.cc ${sources} ${headers})
21
target_include_directories(simpleG4 PRIVATE ${PROJECT_SOURCE_DIR}/include)
22
target_link_libraries(simpleG4 PRIVATE ${Geant4_LIBRARIES} ${ROOT_LIBRARIES})
23

24
# Copia run.mac al build/
25
set(SCRIPTS run.mac)
26
foreach(_script ${SCRIPTS})
27
    configure_file(${PROJECT_SOURCE_DIR}/${_script} ${PROJECT_BINARY_DIR}/${_script} COPYONLY)
28
endforeach()

1
#include "G4RunManagerFactory.hh"
2
#include "G4UImanager.hh"
3
#include "G4VisExecutive.hh"
4
#include "G4UIExecutive.hh"
5

6
#include "DetectorConstruction.hh"
7
#include "PhysicsList.hh"
8
#include "ActionInitialization.hh"
9

10
int main(int argc, char** argv) {
11
    // Modo multi-hilo
12
    auto* runManager = G4RunManagerFactory::CreateRunManager(G4RunManagerType::MT);
13

14
    // Inicializa clases
15
    runManager->SetUserInitialization(new DetectorConstruction());
16
    runManager->SetUserInitialization(new PhysicsList());
17
    runManager->SetUserInitialization(new ActionInitialization());
18

19
    runManager->Initialize();
20

21
    // Visualización
22
    auto* visManager = new G4VisExecutive();
23
    visManager->Initialize();
24

25
    // UI (lo que tiene que hacer )
26
    auto* UImanager = G4UImanager::GetUIpointer();
27

28
    if (argc == 1) {
29
        auto* ui = new G4UIExecutive(argc, argv);
30
        UImanager->ApplyCommand("/control/execute run.mac");
31
        ui->SessionStart();
32
        delete ui;
33
    } else {
34
        G4String command = "/control/execute ";
35
        UImanager->ApplyCommand(command + argv[1]);
36
    }
37

38
    delete visManager;
39
    delete runManager;
40
    return 0;
41
}

1
#ifndef ACTION_INITIALIZATION_HH
2
#define ACTION_INITIALIZATION_HH
3

4
#include "G4VUserActionInitialization.hh"
5

6
class ActionInitialization : public G4VUserActionInitialization {
7
public:
8
    ActionInitialization();
9
    ~ActionInitialization() override;
10

11
    void BuildForMaster() const override;
12
    void Build() const override;
13
};
14

15
#endif

1
#include "ActionInitialization.hh"
2
#include "PrimaryGeneratorAction.hh"
3

4
ActionInitialization::ActionInitialization() = default;
5
ActionInitialization::~ActionInitialization() = default;
6

7
void ActionInitialization::BuildForMaster() const {
8
    // Hilo maestro (opcional)
9
}
10

11
void ActionInitialization::Build() const {
12
    SetUserAction(new PrimaryGeneratorAction());  // Crea pistola por hilo
13
}

1
#ifndef PRIMARY_GENERATOR_ACTION_HH
2
#define PRIMARY_GENERATOR_ACTION_HH
3

4
#include "G4VUserPrimaryGeneratorAction.hh"
5
#include "G4ParticleGun.hh"
6

7
class PrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction {
8
public:
9
    PrimaryGeneratorAction();
10
    ~PrimaryGeneratorAction() override;
11
    void GeneratePrimaries(G4Event*) override;
12

13
private:
14
    G4ParticleGun* fParticleGun = nullptr;
15
};
16

17
#endif

1
#include "PrimaryGeneratorAction.hh"
2
#include "G4ParticleTable.hh"
3
#include "G4SystemOfUnits.hh"
4

5
PrimaryGeneratorAction::PrimaryGeneratorAction() {
6
    fParticleGun = new G4ParticleGun(1);
7
    auto* particle = G4ParticleTable::GetParticleTable()->FindParticle("e-");
8
    if (!particle) {
9
        G4cerr << "ERROR: Partícula 'e-' no encontrada!\n";
10
        return;
11
    }
12
    fParticleGun->SetParticleDefinition(particle);
13
    fParticleGun->SetParticleEnergy(1.0 * MeV);
14
    fParticleGun->SetParticlePosition(G4ThreeVector(0, 0, -20*cm));
15
    fParticleGun->SetParticleMomentumDirection(G4ThreeVector(0, 0, 1));
16
}
17

18
PrimaryGeneratorAction::~PrimaryGeneratorAction() { delete fParticleGun; }
19

20
void PrimaryGeneratorAction::GeneratePrimaries(G4Event* event) {
21
    fParticleGun->GeneratePrimaryVertex(event);  // ¡DISPARA!
22
}

1
#ifndef DETECTOR_CONSTRUCTION_HH
2
#define DETECTOR_CONSTRUCTION_HH
3

4
#include "G4VUserDetectorConstruction.hh"
5
#include "G4LogicalVolume.hh"
6

7
class DetectorConstruction : public G4VUserDetectorConstruction {
8
public:
9
    DetectorConstruction();
10
    ~DetectorConstruction() override;
11
    G4VPhysicalVolume* Construct() override;
12

13
private:
14
    G4LogicalVolume* fLogicTarget = nullptr;
15
};
16

17
#endif

1
#include "DetectorConstruction.hh"
2
#include "G4Box.hh"
3
#include "G4LogicalVolume.hh"
4
#include "G4PVPlacement.hh"
5
#include "G4NistManager.hh"
6
#include "G4SystemOfUnits.hh"
7

8
DetectorConstruction::DetectorConstruction() = default;
9
DetectorConstruction::~DetectorConstruction() = default;
10

11
G4VPhysicalVolume* DetectorConstruction::Construct() {
12
    auto* nist = G4NistManager::Instance();
13
    auto* air = nist->FindOrBuildMaterial("G4_AIR");
14
    auto* water = nist->FindOrBuildMaterial("G4_WATER");
15

16
    // Mundo
17
    G4double worldSize = 1.0 * m;
18
    auto* worldSolid = new G4Box("World", worldSize/2, worldSize/2, worldSize/2);
19
    auto* worldLV = new G4LogicalVolume(worldSolid, air, "World");
20
    auto* worldPV = new G4PVPlacement(nullptr, {}, worldLV, "World", nullptr, false, 0);
21

22
    // Blanco
23
    G4double targetSize = 10.0 * cm;
24
    auto* targetSolid = new G4Box("Target", targetSize/2, targetSize/2, targetSize/2);
25
    fLogicTarget = new G4LogicalVolume(targetSolid, water, "Target");
26
    new G4PVPlacement(nullptr, {}, fLogicTarget, "Target", worldLV, false, 0);
27

28
    return worldPV;
29
}

1
#ifndef PHYSICS_LIST_HH
2
#define PHYSICS_LIST_HH
3

4
#include "G4VModularPhysicsList.hh"
5

6
class PhysicsList : public G4VModularPhysicsList {
7
public:
8
    PhysicsList();
9
    ~PhysicsList() override;
10
};
11

12
#endif

1
#include "PhysicsList.hh"
2
#include "G4EmStandardPhysics.hh"
3

4
PhysicsList::PhysicsList() {
5
    RegisterPhysics(new G4EmStandardPhysics());
6
}
7

8
PhysicsList::~PhysicsList() = default;