From 6dcb2562525503c5af67b36987c2d052811abc89 Mon Sep 17 00:00:00 2001 From: Alexis Pereda Date: Tue, 13 May 2025 01:06:43 +0200 Subject: [PATCH 1/2] Proof of concept on generic filters (see long part) The entrypoint is in the base actor interface, using filter member. This string can be defined to a Python expression like: "particle_name == "gamma" and pre_kinetic_energy <= 20 * MeV" A Transformer will: - pre compute constants (e.g. 20 * MeV will become a direct value); - turn attribute names into function calls to acquire its value. The AST is then used as the body of a Python function. This function is given to the C++-side corresponding base actor to be used as the filter. This POC works, though it is noticeably slower than another experiment using a JIT compiled C++ function (using ROOT.gInterpreter). --- core/opengate_core/opengate_core.cpp | 3 + .../opengate_lib/GateFilterData.cpp | 1 + .../opengate_lib/GateFilterData.h | 27 +++ .../opengate_core/opengate_lib/GateVActor.cpp | 22 +- core/opengate_core/opengate_lib/GateVActor.h | 7 + .../opengate_lib/pyGateFilterData.cpp | 10 + .../opengate_lib/pyGateVActor.cpp | 1 + opengate/actors/base.py | 99 ++++++++ opengate/filters/ast.py | 79 +++++++ opengate/tests/src/test023_filters_generic.py | 212 ++++++++++++++++++ 10 files changed, 459 insertions(+), 2 deletions(-) create mode 100644 core/opengate_core/opengate_lib/GateFilterData.cpp create mode 100644 core/opengate_core/opengate_lib/GateFilterData.h create mode 100644 core/opengate_core/opengate_lib/pyGateFilterData.cpp create mode 100644 opengate/filters/ast.py create mode 100644 opengate/tests/src/test023_filters_generic.py diff --git a/core/opengate_core/opengate_core.cpp b/core/opengate_core/opengate_core.cpp index b0c02b93e..d8b636e46 100644 --- a/core/opengate_core/opengate_core.cpp +++ b/core/opengate_core/opengate_core.cpp @@ -307,6 +307,8 @@ void init_GateTrackCreatorProcessFilter(py::module &); void init_GateKineticEnergyFilter(py::module &); +void init_GateFilterData(py::module &); + // Gate actors void init_GateDoseActor(py::module &m); @@ -578,6 +580,7 @@ PYBIND11_MODULE(opengate_core, m) { init_GatePrimaryScatterFilter(m); init_GateTrackCreatorProcessFilter(m); init_GateKineticEnergyFilter(m); + init_GateFilterData(m); init_GateThresholdAttributeFilter(m); init_itk_image(m); init_GateImageNestedParameterisation(m); diff --git a/core/opengate_core/opengate_lib/GateFilterData.cpp b/core/opengate_core/opengate_lib/GateFilterData.cpp new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/core/opengate_core/opengate_lib/GateFilterData.cpp @@ -0,0 +1 @@ + diff --git a/core/opengate_core/opengate_lib/GateFilterData.h b/core/opengate_core/opengate_lib/GateFilterData.h new file mode 100644 index 000000000..74d259b4d --- /dev/null +++ b/core/opengate_core/opengate_lib/GateFilterData.h @@ -0,0 +1,27 @@ +#ifndef OPENGATE_CORE_OPENGATE_LIB_GATEFILTERDATA_H +#define OPENGATE_CORE_OPENGATE_LIB_GATEFILTERDATA_H + +#include + +namespace attr { + +struct ParticleName; +struct PreKineticEnergy; + +} // namespace attr + +template struct GetAttr; + +template <> struct GetAttr { + static std::string get(G4Step *step) { + return step->GetTrack()->GetParticleDefinition()->GetParticleName(); + } +}; + +template <> struct GetAttr { + static double get(G4Step *step) { + return step->GetPreStepPoint()->GetKineticEnergy(); + } +}; + +#endif diff --git a/core/opengate_core/opengate_lib/GateVActor.cpp b/core/opengate_core/opengate_lib/GateVActor.cpp index 68064703c..2fb020907 100644 --- a/core/opengate_core/opengate_lib/GateVActor.cpp +++ b/core/opengate_core/opengate_lib/GateVActor.cpp @@ -110,14 +110,14 @@ bool GateVActor::HasAction(const std::string &action) { bool GateVActor::IsSensitiveDetector() { return HasAction("SteppingAction"); }; void GateVActor::PreUserTrackingAction(const G4Track *track) { - for (auto f : fFilters) { + for (auto f : fFilters) { // TODO: does not seem to do anything if (!f->Accept(track)) return; } } void GateVActor::PostUserTrackingAction(const G4Track *track) { - for (auto f : fFilters) { + for (auto f : fFilters) { // TODO: does not seem to do anything if (!f->Accept(track)) return; } @@ -140,6 +140,24 @@ G4bool GateVActor::ProcessHits(G4Step *step, G4TouchableHistory *) { => so we decide to simplify and remove "touchable" in the following. */ + // if using C++-compiled function + // if (fFilter) { + // if (fFilter(reinterpret_cast(step))) + // SteppingAction(step); + // return true; + // } + + // else, if using Python pybind function + if (fFilter) { + py::gil_scoped_acquire gil_acquire; + auto accept = fFilter(step); + if (py::cast(accept)) { + // py::gil_scoped_release gil_release; + SteppingAction(step); + } + return true; + } + // if the operator is AND, we perform the SteppingAction only if ALL filters // are true (If only one is false, we stop and return) if (fOperatorIsAnd) { diff --git a/core/opengate_core/opengate_lib/GateVActor.h b/core/opengate_core/opengate_lib/GateVActor.h index 92abaaa32..1d84be4dc 100644 --- a/core/opengate_core/opengate_lib/GateVActor.h +++ b/core/opengate_core/opengate_lib/GateVActor.h @@ -12,6 +12,7 @@ #include #include #include +#include #include namespace py = pybind11; @@ -162,6 +163,12 @@ class GateVActor : public G4VPrimitiveScorer { bool fWriteToDisk; GateSourceManager *fSourceManager; + + // Filter function + // using FilterFunction = std::function; + using FilterFunction = py::function; + FilterFunction fFilter; + void SetFilterFunction(FilterFunction filter) { fFilter = filter; } }; #endif // GateVActor_h diff --git a/core/opengate_core/opengate_lib/pyGateFilterData.cpp b/core/opengate_core/opengate_lib/pyGateFilterData.cpp new file mode 100644 index 000000000..0d3de44b6 --- /dev/null +++ b/core/opengate_core/opengate_lib/pyGateFilterData.cpp @@ -0,0 +1,10 @@ +#include "GateFilterData.h" +#include +#include + +namespace py = pybind11; + +void init_GateFilterData(py::module &m) { + m.def("GetAttrParticleName", &GetAttr::get) + .def("GetAttrPreKineticEnergy", &GetAttr::get); +} diff --git a/core/opengate_core/opengate_lib/pyGateVActor.cpp b/core/opengate_core/opengate_lib/pyGateVActor.cpp index 69e1759d1..cd793fa62 100644 --- a/core/opengate_core/opengate_lib/pyGateVActor.cpp +++ b/core/opengate_core/opengate_lib/pyGateVActor.cpp @@ -81,6 +81,7 @@ void init_GateVActor(py::module &m) { // .def_readonly("fActions", &GateVActor::fActions) // avoid wrapping // this -> problems with pickle .def_readwrite("fFilters", &GateVActor::fFilters) + .def("SetFilterFunction", &GateVActor::SetFilterFunction) .def("Close", &GateVActor::Close) .def("InitializeCpp", &GateVActor::InitializeCpp) .def("InitializeUserInfo", &GateVActor::InitializeUserInfo) diff --git a/opengate/actors/base.py b/opengate/actors/base.py index d8eec6aee..a67e8d433 100644 --- a/opengate/actors/base.py +++ b/opengate/actors/base.py @@ -1,3 +1,4 @@ +import ast from box import Box from functools import wraps @@ -6,6 +7,10 @@ from ..base import GateObject, process_cls from ..utility import insert_suffix_before_extension from .actoroutput import ActorOutputRoot +from ..filters.ast import FilterASTTransformer +import ROOT +import tempfile +import opengate_core def _setter_hook_attached_to(self, attached_to): @@ -87,6 +92,7 @@ class ActorBase(GateObject): # hints for IDE attached_to: str + filter: str filters: list filters_boolean_operator: str priority: int @@ -105,6 +111,12 @@ class ActorBase(GateObject): "deprecated": "The user input parameter 'mother' is deprecated. Use 'attached_to' instead. ", }, ), + "filter": ( + "", + { + "doc": "Filter used by this actor. ", + }, + ), "filters": ( [], { @@ -492,6 +504,93 @@ def initialize(self): f"Does the actor class somehow inherit from GateVActor (as it should)?" ) + # set filter function + if self.filter != "": + self._build_and_set_filter_function() + + def _build_and_set_filter_function(self): + tr = FilterASTTransformer() + e = ast.parse(self.filter, mode="eval") + e = tr.visit(e) + + name = "local_filter" + args = ast.arguments( + posonlyargs=[], + args=[ast.arg(arg="step")], + kwonlyargs=[], + kw_defaults=[], + defaults=[], + ) + body = [ast.Return(value=e.body)] + e = ast.FunctionDef(name=name, args=args, body=body, decorator_list=[]) + + imports = [ + ast.Import(names=[ast.alias(name="opengate_core", asname=None)]), + ast.Import(names=[ast.alias(name="opengate.filters.ast", asname=None)]), + ast.ImportFrom( + module="filters.ast", + names=[ + ast.alias(name="attr_particle_name", asname=None), + ], + level=2, + ), + ] + + module = ast.Module(body=[*imports, e], type_ignores=[]) + ast.fix_missing_locations(module) + + exec(compile(module, filename="", mode="exec"), globals()) + + # include_paths = [ + # "/home/alexis/work/external/geant4/geant4-v11.3.0/source/track/include", + # "/home/alexis/work/external/geant4/geant4-v11.3.0/source/global/management/include", + # "/home/alexis/work/external/geant4/geant4-v11.3.0/source/particles/management/include", + # "/home/alexis/work/external/geant4/geant4-v11.3.0/source/geometry/management/include", + # "/home/alexis/work/external/geant4/geant4-v11.3.0/source/global/HEPGeometry/include", + # "/home/alexis/work/external/geant4/geant4-v11.3.0/source/materials/include", + # "/home/alexis/work/external/geant4/geant4-v11.3.0/build/source/global/include", + # ] + + # cpp_fun = """ + # bool cpp_local_filter(void* ptr) { + # auto* step = reinterpret_cast(ptr); + # return step->GetTrack()->GetParticleDefinition()->GetParticleName() == "proton"; + # } + # """ + # for include_path in include_paths: + # ROOT.gInterpreter.AddIncludePath(include_path) + # ROOT.gInterpreter.Declare("#include ") + # ROOT.gInterpreter.Declare("#include ") + # ROOT.gInterpreter.Declare("#include ") + # ROOT.gInterpreter.Declare(cpp_fun) + + # cpp_code = """ + # #include + # #include + # #include + # + # bool cpp_local_filter(void* ptr) { + # auto* step = reinterpret_cast(ptr); + # return step->GetTrack()->GetParticleDefinition()->GetParticleName() == "proton"; + # } + # """ + # + # cpp_file = "" + # with tempfile.NamedTemporaryFile(suffix=".C", mode="w", delete=False) as f: + # f.write(cpp_code) + # cpp_file = f.name + # + # for include_path in include_paths: + # ROOT.gSystem.AddIncludePath(f"-I{include_path}") + + # ROOT.gSystem.SetMakeSharedLib(f"g++ -O2 -Wall -fPIC -shared -o $LibName $ObjectFiles") + # ROOT.gSystem.CompileMacro(cpp_file, "kO") + # ROOT.gSystem.Load("/tmp/tmpfhe1bkxu_C.so") + + self.SetFilterFunction(local_filter) + # self.SetFilterFunction(ROOT.cpp_local_filter) + # self.SetFilterFunction(llocal_filter) + def _init_user_output_instance(self): for output_name, output_config in self._processed_user_output_config.items(): try: diff --git a/opengate/filters/ast.py b/opengate/filters/ast.py new file mode 100644 index 000000000..df3ac7ad8 --- /dev/null +++ b/opengate/filters/ast.py @@ -0,0 +1,79 @@ +import ast +import inspect +from typing import Callable, Any +from ..utility import g4_units +import opengate_core as g4 + + +# make local variables for each G4 unit +# TODO define guideline for unit naming when * or / +for key in g4_units: + locals().update({key: g4_units[key]}) + + +class Attribute: + name: str + get: Callable[[g4.G4Step], Any] + + def __init__(self, name, get): + self.name = name + self.get = get + + +def attr_particle_name(step: g4.G4Step): + return g4.GetAttrParticleName(step) + # return step.GetTrack().GetParticleDefinition().GetParticleName() + + +# particle_name = Attribute("particle_name", attr_particle_name) +particle_name = Attribute("particle_name", g4.GetAttrParticleName) +pre_kinetic_energy = Attribute("pre_kinetic_energy", g4.GetAttrPreKineticEnergy) + + +class FilterASTTransformer(ast.NodeTransformer): + def fn_name_from_attr(self, node): + f_src = inspect.getsource(eval(ast.unparse(node)).get) + tree = ast.parse(f_src) + f_name = tree.body[0].name + return f_name + + def visit_Name(self, node): + node_type = eval(f"type({node.id})") + if node_type is Attribute: + # Method 1 -- using local functions + # f_name = self.fn_name_from_attr(node) + # func = ast.Name(id=f"{f_name}", ctx=ast.Load()) + + # Method 2 -- using opengate_core functions + fn = eval(ast.unparse(node)).get + print(fn.__module__) + + func = ast.Attribute( + value=ast.Name(id="opengate_core", ctx=ast.Load()), + attr=fn.__name__, + ctx=ast.Load(), + ) + + args = [ast.Name(id="step", ctx=ast.Load())] + + return ast.Call(func=func, args=args, keywords=[]) + else: + value = eval(ast.unparse(node)) + return ast.Constant(value=value) + + # resolve constant computations (e.g. 5 * MeV) + def visit_BinOp(self, node: ast.BinOp): + self.generic_visit(node) + if isinstance(node.left, ast.Constant) and isinstance(node.right, ast.Constant): + value = eval(ast.unparse(node)) + return ast.Constant(value=value) + else: + return node + + def visit_Expr(self, node: ast.Expr): + self.generic_visit(node) + return node + + def visit_Compare(self, node: ast.Compare): + self.generic_visit(node) + return node diff --git a/opengate/tests/src/test023_filters_generic.py b/opengate/tests/src/test023_filters_generic.py new file mode 100644 index 000000000..8a7ee7147 --- /dev/null +++ b/opengate/tests/src/test023_filters_generic.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +from box import Box +import click +import matplotlib.pyplot as plt +import numpy as np +import opengate as gate +import pathlib +import pyvista +import SimpleITK as sitk +from opengate.filters.ast import FilterASTTransformer +import ast + + +current_path = pathlib.Path(__file__).parent.resolve() +data_path = current_path / "data" +output_path = current_path / "output" +output_file = output_path / "dose.mhd" + +alpha_channel = -1 +colors = Box( + { + "invisible": [0, 0, 0, 0], + "red": [1, 0, 0, 1], + "green": [0, 1, 0, 1], + "blue": [0, 0, 1, 1], + "cyan": [0, 1, 1, 1], + "magenta": [1, 0, 1, 1], + "yellow": [1, 1, 0, 1], + "grey": [0.7, 0.7, 0.7, 1], + "white": [1, 1, 1, 1], + "pink": [1, 0.75, 0.79, 1], + "orange": [1, 0.5, 0, 1], + } +) + + +def simulation(n: int, visu=False): + # units + m = gate.g4_units.m + cm = gate.g4_units.cm + mm = gate.g4_units.mm + um = gate.g4_units.um + MeV = gate.g4_units.MeV + deg = gate.g4_units.deg + + tr = FilterASTTransformer() + e = ast.parse("particle_name == 'proton'") + e = tr.visit(e) + print(ast.dump(e)) + + # create the simulation + sim = gate.Simulation() + + sim.progress_bar = True + + # main user options + ui = sim.user_info + ui.g4_verbose = False + ui.g4_verbose_level = 1 + ui.visu = visu + ui.visu_type = "vrml_file_only" + ui.visu_filename = str(output_path / f"visu_{n}.wrl") + ui.random_seed = "auto" + ui.number_of_threads = 4 + + # change world size + world = sim.world + world.size = [5 * m, 5 * m, 5 * m] + world.color[alpha_channel] = 0 + + # water box + waterbox = sim.add_volume("Box", "waterbox") + waterbox.size = [31 * cm, 31 * cm, 31 * cm] + waterbox.translation = [0 * mm, 0 * mm, 0 * mm] + waterbox.material = "G4_WATER" + waterbox.set_max_step_size(0.1 * mm) + waterbox.color = colors.cyan + + # physics + sim.physics_manager.physics_list_name = "G4EmStandardPhysics_option4" + sim.physics_manager.set_production_cut("world", "gamma", 10 * m) + sim.physics_manager.set_production_cut("world", "electron", 10 * m) + sim.physics_manager.set_production_cut("world", "positron", 10 * m) + + if visu: + sim.physics_manager.set_production_cut(waterbox.name, "gamma", 1 * mm) + sim.physics_manager.set_production_cut(waterbox.name, "electron", 1 * mm) + sim.physics_manager.set_production_cut(waterbox.name, "positron", 1 * mm) + else: + sim.physics_manager.set_production_cut(waterbox.name, "gamma", 1 * um) + sim.physics_manager.set_production_cut(waterbox.name, "electron", 1 * um) + sim.physics_manager.set_production_cut(waterbox.name, "positron", 1 * um) + + sim.physics_manager.set_user_limits_particles(["gamma", "electron"]) + + # source + source = sim.add_source("GenericSource", "beam") + source.particle = "e-" + source.energy.mono = 20 * MeV + source.position.type = "point" + source.position.translation = [0 * mm, 0 * mm, 1 * m + 15.5 * cm] + source.direction.type = "iso" + source.direction.theta = [0 * deg, 3 * deg] # ZOX plane + source.direction.phi = [0 * deg, 360 * deg] # YOX plane + source.n = n / ui.number_of_threads + + # dose actor + dose = sim.add_actor("DoseActor", "dose") + dose.attached_to = waterbox + dose.output_filename = output_file + dose.size = [31, 31, 155] + dose.spacing = [1 * cm, 1 * cm, 2 * mm] + dose.hit_type = "random" + dose.dose.active = True + dose.dose_uncertainty.active = True + + fp = sim.add_filter("ParticleFilter", "fp") + fp.particle = "gamma" + + dose.filters.append(fp) + + # dose.filter = "5 == 0" + # dose.filter = "particle_name == 'gamma' and 5 == 5 or pre_kinetic_energy < 10 * MeV and False" + + # add stat actor + stats = sim.add_actor("SimulationStatisticsActor", "stats") + stats.track_types_flag = True + + # start simulation + sim.run() + + # print results at the end + print(stats) + + +def analysis(): + img = sitk.ReadImage(str(output_file).replace(".mhd", "_dose.mhd")) + data = np.array(sitk.GetArrayFromImage(img)) + profile = [np.sum(plan) for plan in data] + profile = profile[::-1] # reverse order + profile = profile[: len(profile) // 2] + + # Dose profile figure + fig, ax = plt.subplots(figsize=(5.5, 3.8), dpi=300) + plt.title("Depth dose profile") + ax.set_xlabel("Depth (voxel)") + ax.set_ylabel("Dose (Gy)") + + ax.plot(profile) + + fig.savefig("depth_dose_profile.png") + plt.show() + plt.close(fig) + + +def visualisation(n: int): + pl = pyvista.Plotter() + pl.import_vrml(str(output_path / f"visu_{n}.wrl")) + pl.add_axes(line_width=5, color="white") + pl.background_color = "black" + for actor in pl.renderer.GetActors(): + actor.GetProperty().SetOpacity(0.7) + pl.show() + + +@click.command() +@click.option( + "-s", + "--sim", + "--simulation", + "enable_sim", + is_flag=True, + default=False, + help="enable simulation", +) +@click.option( + "-a", + "--analysis", + "enable_analysis", + is_flag=True, + default=False, + help="enable analysis", +) +@click.option( + "-V", + "--visu", + "--visualisation", + "enable_visu", + is_flag=True, + default=False, + help="enable visualisation", +) +@click.option( + "-n", "--primaries", "n", type=str, default="1e2", help="number of primaries" +) +def main(enable_sim: bool, enable_analysis: bool, enable_visu: bool, n: str): + n = int(float(n)) # handle scientific notation + + if enable_sim: + simulation(n, visu=enable_visu) + + if enable_analysis: + analysis() + + if enable_visu: + visualisation(n) + + +if __name__ == "__main__": + main() From c7ae8975b3b5812ff2acd74154c5504475ba3e70 Mon Sep 17 00:00:00 2001 From: Alexis Pereda Date: Tue, 13 May 2025 18:13:19 +0200 Subject: [PATCH 2/2] add all attributes (from digitizer) and a debug function --- .../opengate_lib/GateFilterData.h | 412 +++++++++++++++++- .../opengate_lib/GateUserEventInformation.cpp | 2 +- .../opengate_lib/GateUserEventInformation.h | 2 +- .../opengate_lib/pyGateFilterData.cpp | 81 +++- opengate/actors/base.py | 5 +- opengate/filters/ast.py | 111 ++++- opengate/tests/src/output/dose_dose.mhd | 13 + opengate/tests/src/output/dose_dose.raw | Bin 0 -> 1191640 bytes .../src/output/dose_dose_uncertainty.mhd | 13 + .../src/output/dose_dose_uncertainty.raw | Bin 0 -> 1191640 bytes opengate/tests/src/output/dose_edep.mhd | 13 + opengate/tests/src/output/dose_edep.raw | Bin 0 -> 1191640 bytes opengate/tests/src/test023_filters_generic.py | 5 +- 13 files changed, 638 insertions(+), 19 deletions(-) create mode 100644 opengate/tests/src/output/dose_dose.mhd create mode 100644 opengate/tests/src/output/dose_dose.raw create mode 100644 opengate/tests/src/output/dose_dose_uncertainty.mhd create mode 100644 opengate/tests/src/output/dose_dose_uncertainty.raw create mode 100644 opengate/tests/src/output/dose_edep.mhd create mode 100644 opengate/tests/src/output/dose_edep.raw diff --git a/core/opengate_core/opengate_lib/GateFilterData.h b/core/opengate_core/opengate_lib/GateFilterData.h index 74d259b4d..e82306dd7 100644 --- a/core/opengate_core/opengate_lib/GateFilterData.h +++ b/core/opengate_core/opengate_lib/GateFilterData.h @@ -1,20 +1,94 @@ #ifndef OPENGATE_CORE_OPENGATE_LIB_GATEFILTERDATA_H #define OPENGATE_CORE_OPENGATE_LIB_GATEFILTERDATA_H +#include #include +#include + +#include "GatePrimaryScatterFilter.h" +#include "GateUniqueVolumeIDManager.h" +#include "GateUserEventInformation.h" namespace attr { -struct ParticleName; +// Energy +struct TotalEnergyDeposit; +struct PostKineticEnergy; struct PreKineticEnergy; +struct KineticEnergy; +struct TrackVertexKineticEnergy; +struct EventKineticEnergy; + +// Time +struct LocalTime; +struct GlobalTime; +struct PreGlobalTime; +struct TimeFromBeginOfEvent; +struct TrackProperTime; + +// Misc +struct Weight; +struct TrackID; +struct ParentID; +struct EventID; +struct RunID; +struct ThreadID; +struct TrackCreatorProcess; +struct TrackCreatorModelName; +struct TrackCreatorModelIndex; +struct ProcessDefinedStep; +struct ParticleName; +struct ParentParticleName; +struct ParticleType; +struct TrackVolumeName; +struct TrackVolumeCopyNo; +struct PreStepVolumeCopyNo; +struct PostStepVolumeCopyNo; +struct TrackVolumeInstanceID; +struct PreStepUniqueVolumeID; +struct PostStepUniqueVolumeID; +struct PDGCode; +struct HitUniqueVolumeID; + +// Position +struct Position; +struct PostPosition; +struct PrePosition; +struct PrePositionLocal; +struct PostPositionLocal; +struct EventPosition; +struct TrackVertexPosition; + +// Direction +struct Direction; +struct PostDirection; +struct PreDirection; +struct PreDirectionLocal; +struct TrackVertexMomentumDirection; +struct EventDirection; + +// Polarization +struct Polarization; + +// Length +struct StepLength; +struct TrackLength; + +// Scatter information +struct UnscatteredPrimaryFlag; } // namespace attr template struct GetAttr; -template <> struct GetAttr { - static std::string get(G4Step *step) { - return step->GetTrack()->GetParticleDefinition()->GetParticleName(); +// Energy +template <> struct GetAttr { + static double get(G4Step *step) { return step->GetTotalEnergyDeposit(); } +}; + +template <> struct GetAttr { + static double get(G4Step *step) { + return step->GetPostStepPoint()->GetKineticEnergy(); } }; @@ -24,4 +98,334 @@ template <> struct GetAttr { } }; +template <> struct GetAttr { + static double get(G4Step *step) { + return step->GetPreStepPoint()->GetKineticEnergy(); + } +}; + +template <> struct GetAttr { + static double get(G4Step *step) { + return step->GetTrack()->GetVertexKineticEnergy(); + } +}; + +template <> struct GetAttr { + static double get(G4Step *) { + auto const *event = G4RunManager::GetRunManager()->GetCurrentEvent(); + return event->GetPrimaryVertex(0)->GetPrimary(0)->GetKineticEnergy(); + } +}; + +// Time +template <> struct GetAttr { + static double get(G4Step *step) { + return step->GetPostStepPoint()->GetLocalTime(); + } +}; + +template <> struct GetAttr { + static double get(G4Step *step) { + return step->GetPostStepPoint()->GetGlobalTime(); + } +}; + +template <> struct GetAttr { + static double get(G4Step *step) { + return step->GetPreStepPoint()->GetGlobalTime(); + } +}; + +template <> struct GetAttr { + static double get(G4Step *step) { + auto const *event = G4RunManager::GetRunManager()->GetCurrentEvent(); + auto const globalTime = step->GetTrack()->GetGlobalTime(); + return globalTime - event->GetPrimaryVertex(0)->GetT0(); + } +}; + +template <> struct GetAttr { + static double get(G4Step *step) { return step->GetTrack()->GetProperTime(); } +}; + +// Misc +template <> struct GetAttr { + static double get(G4Step *step) { return step->GetTrack()->GetWeight(); } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + return step->GetTrack()->GetTrackID(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + return step->GetTrack()->GetParentID(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *) { + return G4RunManager::GetRunManager()->GetCurrentEvent()->GetEventID(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *) { + return G4RunManager::GetRunManager()->GetCurrentRun()->GetRunID(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *) { return G4Threading::G4GetThreadId(); } +}; + +template <> struct GetAttr { + static std::string get(G4Step *step) { + auto const *creatorProcess = step->GetTrack()->GetCreatorProcess(); + if (creatorProcess) + return creatorProcess->GetProcessName(); + return "none"; + } +}; + +template <> struct GetAttr { + static std::string get(G4Step *step) { + return step->GetTrack()->GetCreatorModelName(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + return step->GetTrack()->GetCreatorModelIndex(); + } +}; + +template <> struct GetAttr { + static std::string get(G4Step *step) { + auto const *p = step->GetPreStepPoint()->GetProcessDefinedStep(); + if (p) + return p->GetProcessName(); + return "none"; + } +}; + +template <> struct GetAttr { + static std::string get(G4Step *step) { + return step->GetTrack()->GetParticleDefinition()->GetParticleName(); + } +}; + +template <> struct GetAttr { + static std::string get(G4Step *step) { + auto const *event = G4RunManager::GetRunManager()->GetCurrentEvent(); + auto const *info = + dynamic_cast(event->GetUserInformation()); + if (info) { + auto const trackId = step->GetTrack()->GetParentID(); + return info->GetParticleName(trackId); + } + return "no_user_event_info"; + } +}; + +template <> struct GetAttr { + static std::string get(G4Step *step) { + return step->GetTrack()->GetParticleDefinition()->GetParticleType(); + } +}; + +template <> struct GetAttr { + static std::string get(G4Step *step) { + return step->GetTrack()->GetVolume()->GetName(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + return step->GetTrack()->GetVolume()->GetCopyNo(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const *touchable = step->GetPreStepPoint()->GetTouchable(); + auto const depth = touchable->GetHistoryDepth(); + return touchable->GetVolume(depth)->GetCopyNo(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const *touchable = step->GetPostStepPoint()->GetTouchable(); + auto const depth = touchable->GetHistoryDepth(); + return touchable->GetVolume(depth)->GetCopyNo(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + return step->GetTrack()->GetVolume()->GetInstanceID(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto *manager = GateUniqueVolumeIDManager::GetInstance(); + auto const *touchable = step->GetPreStepPoint()->GetTouchable(); + return manager->GetVolumeID(touchable); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto *manager = GateUniqueVolumeIDManager::GetInstance(); + auto const *touchable = step->GetPostStepPoint()->GetTouchable(); + return manager->GetVolumeID(touchable); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + return step->GetTrack()->GetParticleDefinition()->GetPDGEncoding(); + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto *manager = GateUniqueVolumeIDManager::GetInstance(); + auto const processName = + step->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName(); + if (processName == "Transportation") + return manager->GetVolumeID(step->GetPreStepPoint()->GetTouchable()); + else + return manager->GetVolumeID(step->GetPostStepPoint()->GetTouchable()); + } +}; + +// Position +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const pos = step->GetPostStepPoint()->GetPosition(); + return std::vector{pos}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const pos = step->GetPostStepPoint()->GetPosition(); + return std::vector{pos}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const pos = step->GetPreStepPoint()->GetPosition(); + return std::vector{pos}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const *touchable = step->GetPreStepPoint()->GetTouchable(); + auto pos = step->GetPreStepPoint()->GetPosition(); + touchable->GetHistory()->GetTopTransform().ApplyPointTransform(pos); + return std::vector{pos}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const *touchable = step->GetPostStepPoint()->GetTouchable(); + auto pos = step->GetPostStepPoint()->GetPosition(); + touchable->GetHistory()->GetTopTransform().ApplyPointTransform(pos); + return std::vector{pos}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *) { + auto const *event = G4RunManager::GetRunManager()->GetCurrentEvent(); + auto const pos = event->GetPrimaryVertex(0)->GetPosition(); + return std::vector{pos}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const pos = step->GetTrack()->GetVertexPosition(); + return std::vector{pos}; + } +}; + +// Direction +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const dir = step->GetPostStepPoint()->GetMomentumDirection(); + return std::vector{dir}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const dir = step->GetPostStepPoint()->GetMomentumDirection(); + return std::vector{dir}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const dir = step->GetPreStepPoint()->GetMomentumDirection(); + return std::vector{dir}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const *touchable = step->GetPostStepPoint()->GetTouchable(); + auto dir = step->GetPreStepPoint()->GetMomentumDirection(); + touchable->GetHistory()->GetTopTransform().TransformAxis(dir); + return std::vector{dir}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const dir = step->GetTrack()->GetVertexMomentumDirection(); + return std::vector{dir}; + } +}; + +template <> struct GetAttr { + static decltype(auto) get(G4Step *) { + auto const *event = G4RunManager::GetRunManager()->GetCurrentEvent(); + auto const dir = + event->GetPrimaryVertex(0)->GetPrimary(0)->GetMomentumDirection(); + return std::vector{dir}; + } +}; + +// Polarization +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { + auto const pol = step->GetTrack()->GetPolarization(); + return std::vector{pol}; + } +}; + +// Length +template <> struct GetAttr { + static double get(G4Step *step) { return step->GetStepLength(); } +}; + +template <> struct GetAttr { + static double get(G4Step *step) { return step->GetTrack()->GetTrackLength(); } +}; + +// Scatter information +template <> struct GetAttr { + static decltype(auto) get(G4Step *step) { return IsUnscatteredPrimary(step); } +}; + #endif diff --git a/core/opengate_core/opengate_lib/GateUserEventInformation.cpp b/core/opengate_core/opengate_lib/GateUserEventInformation.cpp index c09b8623f..c26b92f07 100644 --- a/core/opengate_core/opengate_lib/GateUserEventInformation.cpp +++ b/core/opengate_core/opengate_lib/GateUserEventInformation.cpp @@ -12,7 +12,7 @@ void GateUserEventInformation::Print() const { // FIXME } -std::string GateUserEventInformation::GetParticleName(G4int track_id) { +std::string GateUserEventInformation::GetParticleName(G4int track_id) const { if (fMapOfParticleName.count(track_id) > 0) { return fMapOfParticleName.at(track_id); } else diff --git a/core/opengate_core/opengate_lib/GateUserEventInformation.h b/core/opengate_core/opengate_lib/GateUserEventInformation.h index 138dd8067..056be2ced 100644 --- a/core/opengate_core/opengate_lib/GateUserEventInformation.h +++ b/core/opengate_core/opengate_lib/GateUserEventInformation.h @@ -21,7 +21,7 @@ class GateUserEventInformation : public G4VUserEventInformation { void Print() const override; - std::string GetParticleName(G4int track_id); + std::string GetParticleName(G4int track_id) const; void BeginOfEventAction(const G4Event *event); diff --git a/core/opengate_core/opengate_lib/pyGateFilterData.cpp b/core/opengate_core/opengate_lib/pyGateFilterData.cpp index 0d3de44b6..288b7979c 100644 --- a/core/opengate_core/opengate_lib/pyGateFilterData.cpp +++ b/core/opengate_core/opengate_lib/pyGateFilterData.cpp @@ -5,6 +5,83 @@ namespace py = pybind11; void init_GateFilterData(py::module &m) { - m.def("GetAttrParticleName", &GetAttr::get) - .def("GetAttrPreKineticEnergy", &GetAttr::get); + m + // Energy + .def("GetAttrTotalEnergyDeposit", &GetAttr::get) + .def("GetAttrPostKineticEnergy", &GetAttr::get) + .def("GetAttrPreKineticEnergy", &GetAttr::get) + .def("GetAttrKineticEnergy", &GetAttr::get) + .def("GetAttrTrackVertexKineticEnergy", + &GetAttr::get) + .def("GetAttrEventKineticEnergy", &GetAttr::get) + + // Time + .def("GetAttrLocalTime", &GetAttr::get) + .def("GetAttrGlobalTime", &GetAttr::get) + .def("GetAttrPreGlobalTime", &GetAttr::get) + .def("GetAttrTimeFromBeginOfEvent", + &GetAttr::get) + .def("GetAttrTrackProperTime", &GetAttr::get) + + // Misc + .def("GetAttrWeight", &GetAttr::get) + .def("GetAttrTrackID", &GetAttr::get) + .def("GetAttrParentID", &GetAttr::get) + .def("GetAttrEventID", &GetAttr::get) + .def("GetAttrRunID", &GetAttr::get) + .def("GetAttrThreadID", &GetAttr::get) + .def("GetAttrTrackCreatorProcess", + &GetAttr::get) + .def("GetAttrTrackCreatorModelName", + &GetAttr::get) + .def("GetAttrTrackCreatorModelIndex", + &GetAttr::get) + .def("GetAttrProcessDefinedStep", &GetAttr::get) + .def("GetAttrParticleName", &GetAttr::get) + .def("GetAttrParentParticleName", &GetAttr::get) + .def("GetAttrParticleType", &GetAttr::get) + .def("GetAttrTrackVolumeName", &GetAttr::get) + .def("GetAttrTrackVolumeCopyNo", &GetAttr::get) + .def("GetAttrPreStepVolumeCopyNo", + &GetAttr::get) + .def("GetAttrPostStepVolumeCopyNo", + &GetAttr::get) + .def("GetAttrTrackVolumeInstanceID", + &GetAttr::get) + .def("GetAttrPreStepUniqueVolumeID", + &GetAttr::get) + .def("GetAttrPostStepUniqueVolumeID", + &GetAttr::get) + .def("GetAttrPDGCode", &GetAttr::get) + .def("GetAttrHitUniqueVolumeID", &GetAttr::get) + + // Position + .def("GetAttrPosition", &GetAttr::get) + .def("GetAttrPostPosition", &GetAttr::get) + .def("GetAttrPrePosition", &GetAttr::get) + .def("GetAttrPrePositionLocal", &GetAttr::get) + .def("GetAttrPostPositionLocal", &GetAttr::get) + .def("GetAttrEventPosition", &GetAttr::get) + .def("GetAttrTrackVertexPosition", + &GetAttr::get) + + // Direction + .def("GetAttrDirection", &GetAttr::get) + .def("GetAttrPostDirection", &GetAttr::get) + .def("GetAttrPreDirection", &GetAttr::get) + .def("GetAttrPreDirectionLocal", &GetAttr::get) + .def("GetAttrTrackVertexMomentumDirection", + &GetAttr::get) + .def("GetAttrEventDirection", &GetAttr::get) + + // Polarization + .def("GetAttrPolarization", &GetAttr::get) + + // Length + .def("GetAttrStepLength", &GetAttr::get) + .def("GetAttrTrackLength", &GetAttr::get) + + // Scatter information + .def("GetAttrUnscatteredPrimaryFlag", + &GetAttr::get); } diff --git a/opengate/actors/base.py b/opengate/actors/base.py index a67e8d433..bd4d1dada 100644 --- a/opengate/actors/base.py +++ b/opengate/actors/base.py @@ -525,12 +525,13 @@ def _build_and_set_filter_function(self): e = ast.FunctionDef(name=name, args=args, body=body, decorator_list=[]) imports = [ + ast.Import(names=[ast.alias(name="numpy", asname="np")]), ast.Import(names=[ast.alias(name="opengate_core", asname=None)]), ast.Import(names=[ast.alias(name="opengate.filters.ast", asname=None)]), ast.ImportFrom( module="filters.ast", names=[ - ast.alias(name="attr_particle_name", asname=None), + ast.alias(name="dbgp", asname=None), ], level=2, ), @@ -539,6 +540,8 @@ def _build_and_set_filter_function(self): module = ast.Module(body=[*imports, e], type_ignores=[]) ast.fix_missing_locations(module) + print(ast.dump(module)) + exec(compile(module, filename="", mode="exec"), globals()) # include_paths = [ diff --git a/opengate/filters/ast.py b/opengate/filters/ast.py index df3ac7ad8..173a28a9b 100644 --- a/opengate/filters/ast.py +++ b/opengate/filters/ast.py @@ -1,5 +1,6 @@ import ast import inspect +import sys from typing import Callable, Any from ..utility import g4_units import opengate_core as g4 @@ -11,6 +12,11 @@ locals().update({key: g4_units[key]}) +def dbgp(s): + print(f"[dbgp] {s}", file=sys.stderr) + return True + + class Attribute: name: str get: Callable[[g4.G4Step], Any] @@ -20,14 +26,99 @@ def __init__(self, name, get): self.get = get -def attr_particle_name(step: g4.G4Step): - return g4.GetAttrParticleName(step) - # return step.GetTrack().GetParticleDefinition().GetParticleName() - - -# particle_name = Attribute("particle_name", attr_particle_name) -particle_name = Attribute("particle_name", g4.GetAttrParticleName) +################################################## +# Energy +total_energy_deposit = Attribute("total_energy_deposit", g4.GetAttrTotalEnergyDeposit) +post_kinetic_energy = Attribute("post_kinetic_energy", g4.GetAttrPostKineticEnergy) pre_kinetic_energy = Attribute("pre_kinetic_energy", g4.GetAttrPreKineticEnergy) +kinetic_energy = Attribute("kinetic_energy", g4.GetAttrKineticEnergy) +track_vertex_kinetic_energy = Attribute( + "track_vertex_kinetic_energy", g4.GetAttrTrackVertexKineticEnergy +) +event_kinetic_energy = Attribute("event_kinetic_energy", g4.GetAttrEventKineticEnergy) + +# Time +local_time = Attribute("local_time", g4.GetAttrLocalTime) +global_time = Attribute("global_time", g4.GetAttrGlobalTime) +pre_global_time = Attribute("pre_global_time", g4.GetAttrPreGlobalTime) +time_from_begin_of_event = Attribute( + "time_from_begin_of_event", g4.GetAttrTimeFromBeginOfEvent +) +track_proper_time = Attribute("track_proper_time", g4.GetAttrTrackProperTime) + +# Misc +weight = Attribute("weight", g4.GetAttrWeight) +track_id = Attribute("track_id", g4.GetAttrTrackID) +parent_id = Attribute("parent_id", g4.GetAttrParentID) +event_id = Attribute("event_id", g4.GetAttrEventID) +run_id = Attribute("run_id", g4.GetAttrRunID) +thread_id = Attribute("thread_id", g4.GetAttrThreadID) +track_creator_process = Attribute( + "track_creator_process", g4.GetAttrTrackCreatorProcess +) +track_creator_model_name = Attribute( + "track_creator_model_name", g4.GetAttrTrackCreatorModelName +) +track_creator_model_index = Attribute( + "track_creator_model_index", g4.GetAttrTrackCreatorModelIndex +) +process_defined_step = Attribute("process_defined_step", g4.GetAttrProcessDefinedStep) +particle_name = Attribute("particle_name", g4.GetAttrParticleName) +parent_particle_name = Attribute("parent_particle_name", g4.GetAttrParentParticleName) +particle_type = Attribute("particle_type", g4.GetAttrParticleType) +track_volume_name = Attribute("track_volume_name", g4.GetAttrTrackVolumeName) +track_volume_copy_no = Attribute("track_volume_copy_no", g4.GetAttrTrackVolumeCopyNo) +pre_step_volume_copy_no = Attribute( + "pre_step_volume_copy_no", g4.GetAttrPreStepVolumeCopyNo +) +post_step_volume_copy_no = Attribute( + "post_step_volume_copy_no", g4.GetAttrPostStepVolumeCopyNo +) +track_volume_instance_id = Attribute( + "track_volume_instance_id", g4.GetAttrTrackVolumeInstanceID +) +pre_step_unique_volume_id = Attribute( + "pre_step_unique_volume_id", g4.GetAttrPreStepUniqueVolumeID +) +post_step_unique_volume_id = Attribute( + "post_step_unique_volume_id", g4.GetAttrPostStepUniqueVolumeID +) +pdg_code = Attribute("pdg_code", g4.GetAttrPDGCode) +hit_unique_volume_id = Attribute("hit_unique_volume_id", g4.GetAttrHitUniqueVolumeID) + +# Position +position = Attribute("position", g4.GetAttrPosition) +post_position = Attribute("post_position", g4.GetAttrPostPosition) +pre_position = Attribute("pre_position", g4.GetAttrPrePosition) +pre_position_local = Attribute("pre_position_local", g4.GetAttrPrePositionLocal) +post_position_local = Attribute("post_position_local", g4.GetAttrPostPositionLocal) +event_position = Attribute("event_position", g4.GetAttrEventPosition) +track_vertex_position = Attribute( + "track_vertex_position", g4.GetAttrTrackVertexPosition +) + +# Direction +direction = Attribute("direction", g4.GetAttrDirection) +post_direction = Attribute("post_direction", g4.GetAttrPostDirection) +pre_direction = Attribute("pre_direction", g4.GetAttrPreDirection) +pre_direction_local = Attribute("pre_direction_local", g4.GetAttrPreDirectionLocal) +track_vertex_momentum_direction = Attribute( + "track_vertex_momentum_direction", g4.GetAttrTrackVertexMomentumDirection +) +event_direction = Attribute("event_direction", g4.GetAttrEventDirection) + +# Polarization +polarization = Attribute("polarization", g4.GetAttrPolarization) + +# Length +step_length = Attribute("step_length", g4.GetAttrStepLength) +track_length = Attribute("track_length", g4.GetAttrTrackLength) + +# Scatter information +unscattered_primary_flag = Attribute( + "unscattered_primary_flag", g4.GetAttrUnscatteredPrimaryFlag +) +################################################## class FilterASTTransformer(ast.NodeTransformer): @@ -58,8 +149,12 @@ def visit_Name(self, node): return ast.Call(func=func, args=args, keywords=[]) else: + value_types = (bool, int, float, str, type(None)) value = eval(ast.unparse(node)) - return ast.Constant(value=value) + if isinstance(value, value_types): + return ast.Constant(value=value) + + return node # resolve constant computations (e.g. 5 * MeV) def visit_BinOp(self, node: ast.BinOp): diff --git a/opengate/tests/src/output/dose_dose.mhd b/opengate/tests/src/output/dose_dose.mhd new file mode 100644 index 000000000..fc10ae3ad --- /dev/null +++ b/opengate/tests/src/output/dose_dose.mhd @@ -0,0 +1,13 @@ +ObjectType = Image +NDims = 3 +BinaryData = True +BinaryDataByteOrderMSB = False +CompressedData = False +TransformMatrix = 1 0 0 0 1 0 0 0 1 +Offset = -150 -150 -154 +CenterOfRotation = 0 0 0 +AnatomicalOrientation = RAI +ElementSpacing = 10 10 2 +DimSize = 31 31 155 +ElementType = MET_DOUBLE +ElementDataFile = dose_dose.raw diff --git a/opengate/tests/src/output/dose_dose.raw b/opengate/tests/src/output/dose_dose.raw new file mode 100644 index 0000000000000000000000000000000000000000..f0160fd46b607f945038d9d54e487d1afe88b592 GIT binary patch literal 1191640 zcmeF4cfb|J_5M*&!LA634U}jE8xaYJUKEw60Yp?Ri1e-?pn`(fH5RNfiZK>!5tXP! z38GPB@399fY5*I?ZURK}%lCKl-0OSpJMYZy&g{IkN^pg011!)36KB@kN^pg011!)36KB@kN^pgKpqMB@;h|C=#fVs z(^8gORjwCOXRy}S+Qf$$-}Zx=vB zmV5*dW=VhqNPq-Lz#{_Or#*5;2CC5i89=umvd4EKApEXG5P-zk%0TTEx0sdYU!+-=xfCNaO z$OLY`_oIVfT(ggN@4NH*BUx1P{(3Tg?Cl2u#&OvXe6Owkc;t0l{ajd@4FR58vf-Y$ zQ5i>mc$DXl`u)K8B$xUL6swfy@?!a$){+1TkN^pUL4f;n7=EIbBtQac0=&-$SZxli*&<3qom*P6dy8S-49?j%40BtQaH0zCIsS^VGsigKQ*Yc+EuKmsH{0wh2J zBtQZrKmsH{0wh2JBtQZrKmsJ-4}qxnX)n34)xs|i9^l<~=xGs+$}26sI1UMfOrYrV zitoRM9KF=N=md(seihySQSEpAK50~a*q#JPKuv(_yP6GaNPq-LfCNZ@1W14cNPq1BbpHHT6}P_e;ykMB5m)y$i~in0UCPYaCcyZzLsa)1 zo9m?=&XnSY0OFT%>V_|+l0Y5_VBN^0ZM2C5NPq-LfCNZ@1d94PA>YwPS@9w zuI0O6<5DKLyBs4+*{9w1>~0TrJ;wR-m$YomyT8)n80t7luba94h3ffY>dkl!+wUs> zsmjB)wz%4-<?ukd(oVk!U>@c5 zysmqW3;X@@3bi2t5+DH*AOR8}0TLhq5+DH*2$jH#m(JX@$(7^1d!M}M&+Gd=b@A8V z+&a-azl0j+)Z2_e(dV5RC4XA+KA}IpNK=!%&QlrB@;Pr_p9iR7rzrMHKdX4KoCHE9 zAlJ8$ZTUal^STfD;uo%qzIcLqkbpS>-TNKplGw6H1VUf$%jX;SfA6PAF+p2NfCNZ@ z1W14cNFXEvMY#^j+RmapCrBFm
k`@0~J_4?t$CdwoM5{O4&c-Oh}U+dF`@BhWa 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%0DPbF033`z_yOM<(7P@?+RJYI4ZZ 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%0AD1!QHq@L7Yb>PNs3csHC4-zt!oi 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 h@@{j)N#xjLiDC(gJ<$-w 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 r&~IEN*1NdkbBfFGSN{KiQ@*%fv