Languages: EN · IT · 日本語 · FR · 中文

Qualité	Déploiement	Documentation

GEMC est une application Geant4 pilotée par des bases de données, destinée aux simulations de détecteurs et de transport des rayonnements. Son API Python permet de définir des configurations complexes de détecteurs sans écrire de code Geant4.

Les descriptions des détecteurs restent indépendantes de l'exécutable : vous les créez en Python, les stockez dans des bases de données ASCII ou SQLite, et GEMC les charge à l'exécution pour lancer la simulation Geant4.

Des plugins C++ prennent en charge la réponse personnalisée des détecteurs, les champs magnétiques, les générateurs d'événements et les formats de sortie.

• Définition des détecteurs principalement en Python
• Aperçu de la géométrie et export VTK avec pyvista
• Bases de données ASCII et SQLite
• Import de géométries depuis des fichiers GDML et CAO
• Visualisation interactive Geant4/Qt et génération d'images hors écran
• Types de détecteurs sensibles intégrés : flux, gPhotonDetector, dosimeter, particle_counter
• Sortie de simulation en ASCII, CSV, JSON et ROOT
• Génération d'événements depuis l'interface graphique, la ligne de commande et les fichiers YAML et LUND
• Prise en charge des champs magnétiques, notamment des champs multipolaires et des cartes au format ASCII
• Module Python analyzer pour lire les sorties de simulation (CSV, ROOT) et en tracer les données
• Variantes de géométrie et configurations dépendant du numéro d'exécution
• Compilation C++ avec Meson et images Docker testées en intégration continue pour Linux amd64 et arm64

Le moyen le plus rapide d'essayer GEMC est de passer par les exemples :

• Démarrage rapide avec Jupyter
• Documentation et exemples
• Galerie d'exemples

Un flux de travail local minimal qui crée un détecteur counter et y simule le passage de 1000 événements :

gemc-system-template -s counter
cd counter
./counter.py
gemc counter.yaml -n=1000
gemc-analyzer counter_t0_digitized.csv totEdep --kind csv --bins 50

La commande de génération à partir d'un modèle crée un système counter, le script Python construit la géométrie et la stocke dans un fichier SQLite gemc.db, gemc lance la simulation et gemc-analyzer trace une variable à partir de la sortie CSV.

Pour les instructions d'installation, consultez le guide d'installation

Les systèmes de détecteurs sont construits et enregistrés dans des bases de données à l'aide de pygemc. Un exemple de définition d'une boîte sensible de type flux :

from pygemc import GVolume, autogeometry

cfg = autogeometry("examples", "counter")

flux = GVolume("flux_box")
flux.description = "air flux box"
flux.make_box(40.0, 40.0, 2.0)
flux.set_position(0, 0, 100)
flux.material = "G4_AIR"
flux.color = "3399FF"
flux.digitization = "flux"
flux.set_identifier("box", 2)
flux.publish(cfg)

Les scripts de géométrie peuvent écrire des bases de données SQLite ou ASCII, afficher la géométrie avec PyVista ou exporter des fichiers VTK.js :

./counter.py --factory sqlite
./counter.py -pv
./counter.py -pvvtk counter -pvz 0.25

PyVista fait partie du flux de travail habituel de GEMC pour la géométrie. Il permet d'inspecter la géométrie des détecteurs avant de lancer Geant4, d'exporter des scènes VTK.js portables pour la documentation et de détecter les erreurs de positionnement ou de rotation lors de la modification des scripts Python de géométrie. Quelques exemples :

Geant4 basic/b2	Matériaux
Tonneau de scintillateurs	CLAS12 DC
Solides booléens	Import CAO

Ouvrez les liens pour explorer les scènes PyVista interactives générées à partir des exemples GEMC.

GEMC se configure avec des fichiers YAML et des options de ligne de commande équivalentes. Un fichier de pilotage compact peut définir le numéro d'exécution, le nombre d'événements, le générateur, les systèmes de géométrie, les modules de sortie et le volume monde :

runno: 1
n: 100
nthreads: 1

gparticle:
  - name: proton
    p: 1500
    vz: -5.0

gsystem:
  - name: counter
    factory: sqlite

gstreamer:
  - filename: counter
    format: csv
  - filename: counter
    format: root

root: G4Box, 15*cm, 15*cm, 15*cm, G4_AIR

Lancer en mode non interactif :

gemc counter.yaml

Lancer avec l'interface graphique Geant4 :

gemc counter.yaml -gui

Exécuter un fichier texte de macro Geant4 (à venir dans la prochaine version) :

gemc counter.yaml -geant4_macro=run.mac
gemc counter.yaml -gui -geant4_macro=vis.mac

Le paramètre YAML équivalent est geant4_macro: run.mac. GEMC exécute la macro après l'initialisation et la configuration de la visualisation, avant d'entrer dans l'interface graphique ou le terminal interactif. Les chemins relatifs sont résolus à partir du répertoire de travail ; Geant4 gère les commentaires, les alias et les commandes /control/execute imbriquées. Les fichiers manquants et les commandes en échec entraînent un code de sortie non nul.

En mode non interactif, la macro contrôle la génération d'événements avec des commandes comme /run/beamOn 100 ; GEMC ne lance ensuite automatiquement ni les événements spécifiés par -n ni ceux répartis par -run_weights. Les conditions du détecteur sont préparées avec -run. Une macro dédiée à la visualisation ne génère aucun événement sauf si elle contient une commande de lancement du faisceau. Sans geant4_macro, le traitement habituel des événements reste inchangé.

Générer une image Geant4 hors écran :

gemc counter.yaml -n=10 \
  -g4view="[{driver: TOOLSSG_OFFSCREEN, segsPerCircle: 200}]" \
  -g4camera="[{phi: -10*deg, theta: 250*deg}]" \
  -g4light="[{phi: 160*deg, theta: 120*deg}]"

La couche de sortie repose sur des plugins. Les formats intégrés des modules de sortie comprennent :

À venir dans la prochaine version : la provenance des trajectoires pourra être enregistrée dans les événements en sortie :

gemc counter.yaml -save_original_track
gemc counter.yaml -save_all_ancestors

-save_original_track renseigne otid dans chaque hit contenant des données de vérité. -save_all_ancestors active également les identifiants des trajectoires d'origine et écrit une banque ancestors sans doublons, contenant chaque trajectoire ayant produit un hit et toute sa chaîne de trajectoires parentes. La sortie CSV utilise un fichier _ancestors.csv distinct ; les formats ASCII, JSON et ROOT incluent cette banque dans les événements en sortie.

pygemc fournit quelques utilitaires pour analyser les sorties CSV ou ROOT. Par exemple :

gemc-analyzer counter_t0_digitized.csv totEdep --kind csv --bins 50
gemc-analyzer out.root E --kind root --detector flux --save energy.png

Par exemple, après avoir exécuté l'exemple b2 avec gemc b2.yaml -n=1000, l'analyseur produit :

gemc-analyzer b2_t0_digitized.csv totEdep --kind csv

gemc-analyzer b2_t0_true_info.csv E --kind csv --data true_info

• Page d'accueil de GEMC
• Journalisation C++ — modèles de messages à paramètres numérotés, filtrage et gestion des erreurs ; les méthodes utilisant ces modèles sont à venir dans la prochaine version
• Passage à l'échelle multithread — mesures de performances multithread et balayage du nombre de threads
• Profilage — métriques de Valgrind callgrind et leur interprétation
• Dépôt de l'API Python
• Dépôt des systèmes GEMC pour CLAS12

Les contributions sont les bienvenues sous forme de pull requests classiques. Avant d'ouvrir une pull request, exécutez les tests Meson pertinents et limitez les modifications à l'objectif visé. Consultez :

• CONTRIBUTING.md
• CODE_OF_CONDUCT.md
• SECURITY.md
• Guide des workflows d'intégration continue

À venir dans la prochaine version : les méthodes de journalisation C++ acceptent des messages complets avec des paramètres numérotés :

log->info(0, "Using %1 threads out of %2 available cores.", useThreads, ncores);

Adaptez les appels utilisant la concaténation dans les plugins externes et recompilez avec les en-têtes GEMC correspondants. Les méthodes transitoires *Template() restent des alias qui transmettent les appels. Consultez le guide de journalisation pour les règles relatives aux marqueurs de substitution et la gestion des textes de diagnostic dynamiques.

Les catalogues de journalisation en anglais sont générés à partir des modèles de messages C++ dans chaque dépôt qui en est responsable. Consultez les catalogues de messages pour les commandes d'extraction, de validation et d'installation. La journalisation détecte automatiquement la langue ; -language=it sélectionne l'italien et -language=en impose l'anglais. En l'absence de traduction, l'anglais est utilisé. Le processus partagé Claude/Codex génère les catalogues dans les langues du projet au moyen de la même tâche cron exécutée les jours de semaine que pour les traductions du site web et des README.

À venir dans la prochaine version : les commandes de l'interface graphique, les info-bulles, les descriptions de géométrie, les messages de l'analyseur et les libellés des boutons SVG utilisent le même choix de langue. Consultez les traductions de l'interface graphique. Les outils Qt Linguist compilent les catalogues de l'interface graphique pendant la compilation ; les traductions des boîtes de dialogue standard utilisent les données linguistiques installées avec Qt.

Si vous utilisez GEMC dans un travail scientifique, citez :

M. Ungaro and the CLAS Collaboration, "The CLAS12 Geant4 simulation," Nuclear Instruments and Methods in Physics Research Section A 959, 163422 (2020). https://doi.org/10.1016/j.nima.2020.163422

La référence au format BibTeX et dans d'autres formats de citation se trouve dans CITATION.md.

GEMC est distribué sous la licence Apache, version 2.0 ; consultez NOTICE pour les mentions d'attribution et les remerciements aux tiers. Le logiciel dépend également de composants tiers soumis à des licences distinctes, notamment Geant4, CLHEP, Qt, ROOT, SQLite et Assimp.

Consultez la feuille de route du projet pour connaître les plans de développement actuels.