triggerflow 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

trigger_loader/cluster_manager.py

@@ -4,9 +4,6 @@ import logging
 from typing import Any
 
 from dask.distributed import Client, LocalCluster
-from dask_cuda import LocalCUDACluster
-from dask_jobqueue import HTCondorCluster
-from dask_kubernetes import KubeCluster
 
 logger = logging.getLogger(__name__)
 
@@ -63,15 +60,18 @@ class ClusterManager:
             self.cluster = LocalCluster(**self.cluster_config)
 
         elif ct == "condor":
+            from dask_jobqueue import HTCondorCluster
             self.cluster = HTCondorCluster(**self.cluster_config)
             if self.jobs and self.jobs > 0:
                 # Scale to the requested number of jobs
                 self.cluster.scale(jobs=self.jobs)
 
         elif ct == "cuda":
+            from dask_cuda import LocalCUDACluster
             self.cluster = LocalCUDACluster(**self.cluster_config)
 
         elif ct == "kubernetes":
+            from dask_kubernetes import KubeCluster
             self.cluster = KubeCluster(**self.cluster_config)
             if self.jobs and self.jobs > 0:
                 try:

trigger_loader/loader.py

@@ -45,8 +45,58 @@ class TriggerLoader:
         )
 
     def _load_sample_json(self, sample_json: str) -> dict:
+        """
+        Loads the JSON and resolves file paths using the priority:
+        1. Explicit 'files' list or directory path (Local/Explicit)
+        2. 'DAS' query (Remote Fallback)
+
+        Returns the canonical coffea fileset format: {dataset_name: [file_path_list]}.
+        """
+        import glob
+        import os
+        
+        # Helper function definition needed here if it's not imported:
+        # def _fetch_files_from_das(das_query: str) -> list[str]: ... (placeholder or actual implementation)
+
         with open(sample_json) as f:
-            return json.load(f)
+            full_data = json.load(f)
+            dataset_metadata = full_data.get("samples", full_data)
+
+        fileset = {}
+        for ds_name, ds_info in dataset_metadata.items():
+            files = []
+            
+            if "files" in ds_info:
+                file_info = ds_info["files"]
+                
+                if isinstance(file_info, list):
+                    files = file_info
+                    
+                elif isinstance(file_info, str):
+                    if os.path.isdir(file_info):
+                        path_glob = os.path.join(file_info, "*.root")
+                        files = glob.glob(path_glob)
+                        logger.info(f"Resolved {len(files)} files from directory {file_info}.")
+                    else:
+                        files = [file_info]
+                
+                if files:
+                    logger.info(f"Using {len(files)} local/explicit files for {ds_name}.")
+ 
+            if not files and "DAS" in ds_info:
+                try:
+                    files = _fetch_files_from_das(ds_info["DAS"]) 
+                    logger.info(f"Resolved {len(files)} files via DAS for {ds_name}.")
+                except NameError:
+                    logger.error("DAS fetching skipped: _fetch_files_from_das is not defined.")
+
+            if not files:
+                logger.warning(f"No files found for dataset: {ds_name}. Skipping.")
+                continue
+
+            fileset[ds_name] = files
+
+        return fileset
 
     def _write_run_metadata_file(self, path: str, duration_s: float | None = None):
         meta_path = f"{path}/run_metadata.json"
@@ -58,9 +108,11 @@ class TriggerLoader:
             json.dump(data, f, indent=2)
 
     def _run(self, runner: processor.Runner, label: str):
-        logger.log(f"Starting processing ({label})...")
+        logger.log(logging.INFO, f"Starting processing ({label})...")
         start = time.time()
         proc = self._build_processor()
+        print(self.fileset)
+        
         acc = runner(
             self.fileset,
             treename="Events",
@@ -68,7 +120,7 @@ class TriggerLoader:
         )
         elapsed = time.time() - start
         self._write_run_metadata_file(self.output_path, elapsed)
-        logger.log(f"Finished in {elapsed:.2f}s (run_uuid={self.run_uuid})")
+        logger.log(logging.INFO, f"Finished in {elapsed:.2f}s (run_uuid={self.run_uuid})")
         return acc
 
     def run_distributed(self, cluster_type: str, cluster_config: dict,

triggerflow/core.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 import json
+import yaml
 import numpy as np
 import tarfile
 import importlib
@@ -8,6 +9,7 @@ from typing import Optional, Dict, Any, Union
 import shutil, warnings
 import importlib.resources as pkg_resources
 import triggerflow.templates 
+from triggerflow.interfaces.uGT import build_ugt_model
 
 
 class ModelConverter(ABC):
@@ -73,37 +75,31 @@ class NoOpConverter(ModelConverter):
 
 
 class HLS4MLStrategy(CompilerStrategy):
-    """HLS4ML compilation strategy for Keras models"""
-    
-    def compile(self, model, workspace: Path, config: Optional[Dict] = None, **kwargs) -> Any:
+    def compile(self, model, workspace: Path, config: Optional[Dict] = None) -> Any:
         import hls4ml
-        
+
         firmware_dir = workspace / "firmware"
         firmware_dir.mkdir(exist_ok=True)
-        
-        cfg = config or hls4ml.utils.config_from_keras_model(model, granularity="name")
 
-        hls_kwargs = {
-            "hls_config": cfg,
-            "output_dir": str(firmware_dir),
-            "io_type": "io_stream",
-            "backend": "Vitis"
-        }
-        hls_kwargs.update(kwargs)
+        hls_config = hls4ml.utils.config_from_keras_model(model, granularity="name")
+        hls_kwargs = {}
+
+        for key in ["project_name", "namespace", "io_type", "backend", "write_weights_txt"]:
+            if key in config:
+                hls_kwargs[key] = config[key]
 
         firmware_model = hls4ml.converters.convert_from_keras_model(
             model,
+            hls_config=hls_config,
+            output_dir=str(firmware_dir),
             **hls_kwargs
         )
 
         firmware_model.compile()
-        if shutil.which("vivado") is not None:
-             firmware_model.build()
-        else:
-            warnings.warn("Vivado not found in PATH. Firmware build failed.", UserWarning)
         firmware_model.save(workspace / "firmware_model.fml")
         return firmware_model
-    
+
+        
     def load_compiled_model(self, workspace: Path) -> Any:
         from hls4ml.converters import link_existing_project
         
@@ -113,46 +109,31 @@ class HLS4MLStrategy(CompilerStrategy):
 
 
 class ConiferStrategy(CompilerStrategy):
-    """Conifer compilation strategy for XGBoost models"""
+    """Conifer compilation strategy for XGBoost models, unified config/workspace handling."""
 
-    def compile(self, model, workspace: Path, config: Optional[Dict] = None, **kwargs) -> Any:
+    def compile(self, model, workspace: Path, config: Optional[Dict] = None) -> Any:
         import conifer
-        import shutil
-        import warnings
         import os
 
         firmware_dir = workspace / "firmware"
         firmware_dir.mkdir(exist_ok=True)
-        os.environ['JSON_ROOT'] = '/eos/user/m/maglowac/TriggerModel/json'
-        os.environ['XILINX_AP_INCLUDE'] = '/eos/user/m/maglowac/TriggerModel/HLS_arbitrary_Precision_Types/include'
 
-        
-        cfg = conifer.backends.xilinxhls.auto_config()#config or conifer.backends.cpp.auto_config()
+        cfg = conifer.backends.xilinxhls.auto_config()
         cfg['OutputDir'] = str(firmware_dir)
-        
-        for key, value in kwargs.items():
-            cfg[key] = value
+        cfg['ProjectName'] = config['project_name']
+        cfg['XilinxPart'] = config['fpga_part']
+        cfg['ClockPeriod'] = config['clock_period']
 
-        print(cfg)
-        firmware_model = conifer.converters.convert_from_xgboost(
-            model,
-            config=cfg
-        )
+        if config:
+            for key, value in config.items():
+                cfg[key] = value
 
-        firmware_model.write()
-        proj_name = cfg.get('ProjectName', 'my_prj')
-        bridge_file = firmware_dir / "bridge.cpp"
-        text = bridge_file.read_text()
-        text = text.replace("my_prj.h", f"{proj_name}.h")
-        bridge_file.write_text(text)
+        firmware_model = conifer.converters.convert_from_xgboost(model, config=cfg)
         firmware_model.compile()
-        if shutil.which("vivado") is not None:
-            firmware_model.build()
-        else:
-            warnings.warn("Vivado not found in PATH. Firmware build failed.", UserWarning)
-
         firmware_model.save(firmware_dir / "firmware_model.fml")
+
         return firmware_model
+
     
     def load_compiled_model(self, workspace: Path) -> Any:
         from conifer import load_model
@@ -384,33 +365,45 @@ class ModelSerializer:
             return model, input_name
         return None, None
 
+
 class TriggerModel:
-    """Main facade class that orchestrates model conversion, compilation, and inference"""
-    
-    def __init__(self, name: str, ml_backend: str, n_outputs:int, compiler: str,
-                 native_model: object, compiler_config: dict = None, scales: dict = None, unscaled_type: str = "ap_fixed<16,6>"):
-        
-        if ml_backend.lower() not in ("keras", "xgboost"):
-            raise ValueError("Only Keras or XGBoost backends are currently supported.")
-        
-        self.name = name
-        self.ml_backend = ml_backend.lower()
-        self.scales = scales
-        self.unscaled_type =  unscaled_type
-        self.n_outputs = n_outputs
-        self.compiler = compiler.lower()
+    def __init__(self, config: Union[str, Path, Dict], native_model, scales):
+        if isinstance(config, (str, Path)):
+            with open(config, "r") as f:
+                config = yaml.safe_load(f)
+        elif not isinstance(config, dict):
+            raise TypeError("config must be a dict or path to a YAML file")
+
         self.native_model = native_model
-        self.compiler_conifg = compiler_config
-        
+        self.scales = scales
+
+        self.compiler_cfg  = config.get("compiler", {})
+        self.subsystem_cfg = config.get("subsystem", {})
+
+        self.name = self.compiler_cfg.get("name", "model")
+        self.ml_backend = self.compiler_cfg.get("ml_backend", "").lower()
+        self.compiler = self.compiler_cfg.get("compiler", "").lower()
+
+        self.n_outputs = self.compiler_cfg.get("n_outputs")
+        self.unscaled_type = self.subsystem_cfg.get("unscaled_type", "ap_fixed<16,6>")
+
+        if self.ml_backend not in ("keras", "xgboost"):
+            raise ValueError("Unsupported backend")
+
         self.workspace_manager = WorkspaceManager()
-        self.converter = ConverterFactory.create_converter(ml_backend, compiler)
-        self.compiler_strategy = CompilerFactory.create_compiler(ml_backend, compiler)
-        
+        self.converter = ConverterFactory.create_converter(self.ml_backend, self.compiler)
+        self.compiler_strategy = CompilerFactory.create_compiler(self.ml_backend, self.compiler)
+
         self.firmware_model = None
         self.model_qonnx = None
         self.input_name = None
         
-        self.workspace_manager.setup_workspace(name, self.ml_backend, self.compiler)
+        
+        self.workspace_manager.setup_workspace(
+            self.name, 
+            self.ml_backend, 
+            self.compiler
+        )
     
     @property
     def workspace(self) -> Path:
@@ -427,8 +420,8 @@ class TriggerModel:
         """Get metadata dictionary"""
         return self.workspace_manager.metadata
     
-    def __call__(self, **compiler_kwargs):
-        """Execute the full model conversion and compilation pipeline"""
+    def __call__(self):
+        """Execute full model conversion and compilation pipeline using YAML config"""
         self.parse_dataset_object()
         
         # Save native model
@@ -445,22 +438,57 @@ class TriggerModel:
             self.input_name = self.model_qonnx.graph.input[0].name
             self.workspace_manager.add_artifact("qonnx", qonnx_path)
             self.workspace_manager.add_version({"qonnx": str(qonnx_path)})
+
         
         # Compile model
         self.firmware_model = self.compiler_strategy.compile(
             self.native_model,
             self.workspace_manager.workspace,
-            self.compiler_conifg, 
-            **compiler_kwargs
+            self.compiler_cfg,
+            **self.compiler_cfg.get("kwargs", {})
         )
         
         self.workspace_manager.add_artifact("firmware", self.workspace_manager.workspace / "firmware")
+        if self.compiler != "conifer" and self.scales is not None:
+            self.build_emulator(
+                self.scales['shifts'],
+                self.scales['offsets'],
+                self.n_outputs,
+                self.unscaled_type
+            )
 
-        if self.compiler is not "conifer" and self.scales is not None:
-           self.build_emulator(self.scales['shifts'], self.scales['offsets'], self.n_outputs, self.unscaled_type)
         
+        if shutil.which("vivado") is not None:
+            build_ugt_model(
+                templates_dir=self.subsystem_cfg.get("templates_dir", Path("templates")),
+                firmware_dir=self.workspace_manager.workspace / "firmware",
+                compiler = self.compiler,
+                model_name=self.name,
+                n_inputs=self.subsystem_cfg["n_inputs"],
+                n_outputs=self.subsystem_cfg.get("n_outputs", self.n_outputs),
+                nn_offsets=self.scales["offsets"],
+                nn_shifts=self.scales["shifts"],
+                muon_size=self.subsystem_cfg.get("muon_size", 0),
+                jet_size=self.subsystem_cfg.get("jet_size", 0),
+                egamma_size=self.subsystem_cfg.get("egamma_size", 0),
+                tau_size=self.subsystem_cfg.get("tau_size", 0),
+                output_type=self.subsystem_cfg.get("output_type", "result_t"),
+                offset_type=self.subsystem_cfg.get("offset_type", "ap_fixed<10,10>"),
+                shift_type=self.subsystem_cfg.get("shift_type", "ap_fixed<10,10>"),
+                object_features=self.subsystem_cfg.get("object_features"),
+                global_features=self.subsystem_cfg.get("global_features")
+            )
+        else:
+            warnings.warn(
+                "Vivado executable not found on the system PATH. "
+                "Skipping FW build. ",
+                UserWarning
+            )
+
+
         self.workspace_manager.add_artifact("firmware", self.workspace_manager.workspace / "firmware")
         self.workspace_manager.save_metadata()
+
     
     @staticmethod
     def parse_dataset_object():
@@ -482,10 +510,16 @@ class TriggerModel:
         predictor = SoftwarePredictor(self.native_model, self.ml_backend)
         return predictor.predict(input_data)
     
-    def qonnx_predict(self, input_data: np.ndarray) -> np.ndarray:
+    def qonnx_predict(self, input_data: np.ndarray) -> np.ndarray | None:
         """Make predictions using QONNX model"""
+        
         if self.model_qonnx is None:
-            raise RuntimeError("QONNX model not available")
+            warnings.warn(
+                "QONNX model is not available. Prediction skipped.",
+                UserWarning
+            )
+            return None 
+            
         predictor = QONNXPredictor(self.model_qonnx, self.input_name)
         return predictor.predict(input_data)
     

triggerflow/interfaces/uGT.py

@@ -0,0 +1,127 @@
+from pathlib import Path
+import shutil
+import pkg_resources
+from jinja2 import Template
+import re
+
+def _render_template(template_file: str, output_file: Path, context: dict):
+    with open(template_file, "r") as f:
+        template_text = f.read()
+
+    template = Template(template_text)
+    rendered = template.render(**context)
+
+    with open(output_file, "w") as f:
+        f.write(rendered)
+
+def build_ugt_model(
+    templates_dir: Path,
+    firmware_dir: Path,
+    compiler: str,
+    model_name: str,
+    n_inputs: int,
+    n_outputs: int,
+    nn_offsets: list,
+    nn_shifts: list,
+    muon_size: int,
+    jet_size: int,
+    egamma_size: int,
+    tau_size: int,
+    output_type: str = "result_t",
+    offset_type: str = "ap_fixed<10,10>",
+    shift_type: str = "ap_fixed<10,10>",
+    object_features: dict = None,
+    global_features: list = None
+):
+    """
+    Render uGT top func.
+    """
+
+
+    if object_features is None:
+        object_features = {
+            "muons": ["pt", "eta_extrapolated", "phi_extrapolated"],
+            "jets": ["et", "eta", "phi"],
+            "egammas": ["et", "eta", "phi"],
+            "taus": ["et", "eta", "phi"]
+        }
+
+    if global_features is None:
+        global_features = [
+            "et.et",
+            "ht.et",
+            "etmiss.et", "etmiss.phi",
+            "htmiss.et", "htmiss.phi",
+            "ethfmiss.et", "ethfmiss.phi",
+            "hthfmiss.et", "hthfmiss.phi"
+        ]
+
+    header_path = firmware_dir / "firmware" / f"{model_name}_project.h"
+    if compiler.lower() == "conifer":
+        output_layer = "score"
+        output_type = "score_arr_t"
+        header_path = firmware_dir / "firmware" / f"{model_name}_project.h"
+        removal_pattern = re.compile(
+            r',\s*score_t\s+tree_scores\[BDT::fn_classes\(n_classes\)\s*\*\s*n_trees\]', 
+            re.DOTALL
+        )
+        modified_content = removal_pattern.sub('', header_path.read_text(encoding='utf-8'))
+        header_path.write_text(modified_content, encoding='utf-8')
+        out = output_layer
+    else:
+        header_content = header_path.read_text(encoding='utf-8')
+        layer_pattern = re.compile(
+            r'result_t\s+(\w+)\[\d+\]\s*\)', 
+            re.DOTALL
+        )
+        match = layer_pattern.search(header_content)
+        layer_name = match.group(1) 
+        output_layer = f"{layer_name}[{n_outputs}]"
+        out = layer_name
+
+        
+    context = {
+    "MODEL_NAME": model_name,
+    "N_INPUTS": n_inputs,
+    "N_OUTPUTS": n_outputs,
+    "NN_OFFSETS": ", ".join(map(str, nn_offsets)),
+    "NN_SHIFTS": ", ".join(map(str, nn_shifts)),
+    "MUON_SIZE": muon_size,
+    "JET_SIZE": jet_size,
+    "EGAMMA_SIZE": egamma_size,
+    "TAU_SIZE": tau_size,
+    "OUTPUT_TYPE": output_type,
+    "OUTPUT_LAYER": output_layer,
+    "OUT": out,
+    "OFFSET_TYPE": offset_type,
+    "SHIFT_TYPE": shift_type,
+    "MUON_FEATURES": object_features["muons"],
+    "JET_FEATURES": object_features["jets"],
+    "EGAMMA_FEATURES": object_features["egammas"],
+    "TAU_FEATURES": object_features["taus"],
+    "GLOBAL_FEATURES": global_features
+    }
+
+    context_tcl = {
+    "MODEL_NAME": model_name,
+    }
+
+    out_path = firmware_dir / "firmware/model-gt.cpp"
+    
+    _render_template(f"{templates_dir}/model-gt.cpp", out_path, context)
+
+    out_path = firmware_dir / "firmware/build_ugt.tcl"
+    _render_template(f"{templates_dir}/build_ugt.tcl", out_path, context_tcl)
+
+    shutil.copy(f"{templates_dir}/data_types.h", firmware_dir / "firmware")
+ 
+    
+    subprocess.run(
+        ["vitis_hls", "-f", "build_ugt.tcl"],
+        cwd=firmware_dir/"firmware",
+        check=True
+    )
+
+
+
+

triggerflow/templates/build_ugt.tcl

@@ -0,0 +1,46 @@
+file mkdir prj_{{ MODEL_NAME }}
+
+open_project -reset prj_{{ MODEL_NAME }}
+
+set_top {{ MODEL_NAME }}_GT
+
+set core_files "model-gt.cpp {{ MODEL_NAME }}_project.cpp"
+
+if { [file exists "BDT.cpp"] } {
+    set all_files "$core_files BDT.cpp"
+} else {
+    set all_files "$core_files"
+}
+
+add_files $all_files -cflags "-std=c++11 -I../"
+
+open_solution -reset solution1
+set_part {xc7vx690t-ffg1927-2}
+
+create_clock -period 25
+set_clock_uncertainty 0
+
+
+config_array_partition -complete_threshold 2
+
+csynth_design
+
+file mkdir firmware
+file mkdir firmware/hdl
+file mkdir firmware/hdl/payload
+file mkdir firmware/hdl/payload/gtl
+file mkdir firmware/hdl/payload/gtl/model
+file mkdir firmware/cfg
+
+set f [open firmware/cfg/model.dep "w"]
+
+if {[file exists prj_{{ MODEL_NAME }}/solution1/syn/vhdl]} {
+    foreach filepath [glob -nocomplain prj_{{ MODEL_NAME }}/solution1/syn/vhdl/*] {
+        set filename [file tail $filepath]
+        file copy -force $filepath firmware/hdl/payload/gtl/model/$filename
+        puts $f "src payload/gtl/model/$filename"
+    }
+}
+
+close $f
+exit

triggerflow/templates/data_types.h

@@ -0,0 +1,524 @@
+#ifndef L1GT_DATATYPES
+#define L1GT_DATATYPES
+
+#include "ap_fixed.h"
+#include <cmath>
+
+// Author: sioni@cern.ch August 2022
+// Object data types defined in https://github.com/cms-l1-globaltrigger/mp7_ugt_legacy/blob/master/firmware/hdl/packages/gtl_pkg.vhd
+// Code mimics Phase 2 L1Trigger Particle Flow data types HLS:
+// https://github.com/cms-sw/cmssw/tree/master/DataFormats/L1TParticleFlow/interface
+
+typedef ap_fixed<9,2> cossin_t;
+typedef ap_fixed<13,7> sinh_t;
+
+static constexpr int N_TABLE = 2048;
+
+/* ---
+ * Constants useful for converting physical units to hardware integers 
+ * --- */
+namespace Scales{
+  static const double MUON_PHI_LSB = 2 * M_PI / 576;
+  static const double CALO_PHI_LSB = 2 * M_PI / 144;
+
+  static const double MUON_ETA_LSB = 0.0870 / 8;
+  static const double CALO_ETA_LSB = 0.0870 / 2;
+
+  static const double MUON_PT_LSB = 0.5;
+  static const double CALO_PT_LSB = 0.5;
+  
+  const int INTPHI_PI = 720;
+
+  static const int MUON_HALF_PI = 144;
+  static const int CALO_HALF_PI = 36;
+}; // namespace Scales
+
+/* ---
+ * Functions for packing and unpacking ap_ objects 
+ * --- */
+template <typename U, typename T>
+inline void pack_into_bits(U& u, unsigned int& start, const T& data) {
+  const unsigned int w = T::width;
+  u(start + w - 1, start) = data(w - 1, 0);
+  start += w;
+}
+
+template <typename U, typename T>
+inline void unpack_from_bits(const U& u, unsigned int& start, T& data) {
+  const unsigned int w = T::width;
+  data(w - 1, 0) = u(start + w - 1, start);
+  start += w;
+}
+
+/* ---
+ * Definitions of the objects received by the GT
+ * --- */
+/* ---
+ * Muon 
+ * --- */
+struct Muon{
+  ap_uint<10> phi_extrapolated;
+  ap_ufixed<9,8> pt;
+  ap_uint<4> quality;
+  ap_int<9> eta_extrapolated;
+  ap_uint<2> iso;
+  ap_uint<1> charge_sign;
+  ap_uint<1> charge_valid;
+  ap_uint<7> index_bits;
+  ap_uint<10> phi_out;
+  ap_uint<8> pt_unconstrained;
+  ap_uint<1> hadronic_shower_trigger;
+  ap_uint<2> impact_parameter;
+
+  static const int BITWIDTH = 64;
+
+  inline void clear(){
+    phi_extrapolated = 0;
+    pt = 0;
+    quality = 0;
+    eta_extrapolated = 0;
+    iso = 0;
+    charge_sign = 0;
+    charge_valid = 0;
+    index_bits = 0;
+    phi_out = 0;
+    pt_unconstrained = 0;
+    hadronic_shower_trigger = 0;
+    impact_parameter = 0;
+  }
+
+  inline ap_uint<BITWIDTH> pack() const{
+    ap_uint<BITWIDTH> ret;
+    unsigned int start = 0;
+    pack_into_bits(ret, start, phi_extrapolated);
+    pack_into_bits(ret, start, pt);
+    pack_into_bits(ret, start, quality);
+    pack_into_bits(ret, start, eta_extrapolated);
+    pack_into_bits(ret, start, iso);
+    pack_into_bits(ret, start, charge_sign);
+    pack_into_bits(ret, start, charge_valid);
+    pack_into_bits(ret, start, index_bits);
+    pack_into_bits(ret, start, phi_out);
+    pack_into_bits(ret, start, pt_unconstrained);
+    pack_into_bits(ret, start, hadronic_shower_trigger);
+    pack_into_bits(ret, start, impact_parameter);
+    return ret;
+  }
+
+  inline void initFromBits(const ap_uint<BITWIDTH> &src){
+    unsigned int start = 0;
+    unpack_from_bits(src, start, phi_extrapolated);
+    unpack_from_bits(src, start, pt);
+    unpack_from_bits(src, start, quality);
+    unpack_from_bits(src, start, eta_extrapolated);
+    unpack_from_bits(src, start, iso);
+    unpack_from_bits(src, start, charge_sign);
+    unpack_from_bits(src, start, charge_valid);
+    unpack_from_bits(src, start, index_bits);
+    unpack_from_bits(src, start, phi_out);
+    unpack_from_bits(src, start, pt_unconstrained);
+    unpack_from_bits(src, start, hadronic_shower_trigger);
+    unpack_from_bits(src, start, impact_parameter);
+  }
+
+  inline static Muon unpack(const ap_uint<BITWIDTH> &src){
+    Muon ret;
+    ret.initFromBits(src);
+    return ret;
+  }
+
+  inline static Muon initFromPhysicalDoubles(const double pt, const double eta, const double phi){
+    Muon ret;
+    ret.clear();
+    ret.pt = pt;
+    ret.eta_extrapolated = round(eta / Scales::MUON_ETA_LSB);
+    ret.phi_extrapolated = round(phi / Scales::MUON_PHI_LSB);
+    return ret;
+  }
+
+  inline static Muon initFromHWInt(int pt, int eta, int phi){
+      Muon muon;
+      muon.clear();
+      muon.pt.V = pt;
+      muon.eta_extrapolated.V = eta;
+      muon.phi_extrapolated.V = phi;
+      return muon;
+  }
+
+}; // struct Muon
+
+/* ---
+ * Jet 
+ * --- */
+struct Jet{
+  ap_ufixed<11,10> et;
+  ap_int<8> eta;
+  ap_uint<8> phi;
+  ap_uint<1> disp;
+  ap_uint<2> quality;
+  ap_uint<2> spare;
+
+  static const int BITWIDTH = 32;
+
+  inline void clear(){
+    et = 0;
+    eta = 0;
+    phi = 0;
+    disp = 0;
+    quality = 0;
+    spare = 0;
+  }
+
+  inline ap_uint<BITWIDTH> pack() const{
+    ap_uint<BITWIDTH> ret;
+    unsigned int start = 0;
+    pack_into_bits(ret, start, et);
+    pack_into_bits(ret, start, eta);
+    pack_into_bits(ret, start, phi);
+    pack_into_bits(ret, start, disp);
+    pack_into_bits(ret, start, quality);
+    pack_into_bits(ret, start, spare);
+    return ret;
+  }
+
+  inline void initFromBits(const ap_uint<BITWIDTH> &src){
+    unsigned int start = 0;
+    unpack_from_bits(src, start, et);
+    unpack_from_bits(src, start, eta);
+    unpack_from_bits(src, start, phi);
+    unpack_from_bits(src, start, disp);
+    unpack_from_bits(src, start, quality);
+    unpack_from_bits(src, start, spare);
+  }
+
+  inline static Jet unpack(const ap_uint<BITWIDTH> &src){
+    Jet ret;
+    ret.initFromBits(src);
+    return ret;
+  }
+
+  inline static Jet initFromPhysicalDoubles(const double et, const double eta, const double phi){
+    Jet ret;
+    ret.clear();
+    ret.et = et;
+    ret.eta = round(eta / Scales::CALO_ETA_LSB);
+    ret.phi = round(phi / Scales::CALO_PHI_LSB);
+    return ret;
+  }
+
+  inline static Jet initFromHWInt(const int et, const int eta, const int phi){
+    Jet ret;
+    ret.clear();
+    ret.et.V = et;
+    ret.eta.V = eta;
+    ret.phi.V = phi;
+    return ret;
+  }
+
+}; // struct Jet
+
+/* ---
+ * e / gamma or tau (same format)
+ * --- */
+struct CaloCommon{
+  ap_ufixed<9,8> et;
+  ap_int<8> eta;
+  ap_uint<8> phi;
+  ap_uint<2> iso;
+  ap_uint<5> spare;
+
+  static const int BITWIDTH = 32;
+
+  inline void clear(){
+    et = 0;
+    eta = 0;
+    phi = 0;
+    iso = 0;
+    spare = 0;
+  }
+
+  inline ap_uint<BITWIDTH> pack() const{
+    ap_uint<BITWIDTH> ret;
+    unsigned int start = 0;
+    pack_into_bits(ret, start, et);
+    pack_into_bits(ret, start, eta);
+    pack_into_bits(ret, start, phi);
+    pack_into_bits(ret, start, iso);
+    pack_into_bits(ret, start, spare);
+    return ret;
+  }
+
+  inline void initFromBits(const ap_uint<BITWIDTH> &src){
+    unsigned int start = 0;
+    unpack_from_bits(src, start, et);
+    unpack_from_bits(src, start, eta);
+    unpack_from_bits(src, start, phi);
+    unpack_from_bits(src, start, iso);
+    unpack_from_bits(src, start, spare);
+  }
+
+  inline static CaloCommon unpack(const ap_uint<BITWIDTH> &src){
+    CaloCommon ret;
+    ret.initFromBits(src);
+    return ret;
+  }
+
+  inline static CaloCommon initFromPhysicalDoubles(const double et, const double eta, const double phi){
+    CaloCommon ret;
+    ret.clear();
+    ret.et = et;
+    ret.eta = round(eta / Scales::CALO_ETA_LSB);
+    ret.phi = round(phi / Scales::CALO_PHI_LSB);
+    return ret;
+  }
+
+  inline static CaloCommon initFromHWInt(const int et, const int eta, const int phi){
+    CaloCommon ret;
+    ret.clear();
+    ret.et.V = et;
+    ret.eta.V = eta;
+    ret.phi.V = phi;
+    return ret;
+  }
+
+}; // struct CaloCommon
+
+typedef CaloCommon EGamma;
+typedef CaloCommon Tau;
+
+/* ---
+ * Scalar Sums
+ * --- */
+struct ET{
+  ap_ufixed<12,11> et;
+  ap_ufixed<12,11> ettem;
+  ap_uint<4> spare;
+  ap_uint<4> minimum_bias_hf;
+
+  static const int BITWIDTH = 32;
+
+  inline void clear(){
+    et = 0;
+    ettem = 0;
+    spare = 0;
+    minimum_bias_hf = 0;
+  }
+
+  inline ap_uint<BITWIDTH> pack() const{
+    ap_uint<BITWIDTH> ret;
+    unsigned int start = 0;
+    pack_into_bits(ret, start, et);
+    pack_into_bits(ret, start, ettem);
+    pack_into_bits(ret, start, spare);
+    pack_into_bits(ret, start, minimum_bias_hf);
+    return ret;
+  }
+
+  inline void initFromBits(const ap_uint<BITWIDTH> &src){
+    unsigned int start = 0;
+    unpack_from_bits(src, start, et);
+    unpack_from_bits(src, start, ettem);
+    unpack_from_bits(src, start, spare);
+    unpack_from_bits(src, start, minimum_bias_hf);
+  }
+
+  inline static ET unpack(const ap_uint<BITWIDTH> &src){
+    ET ret;
+    ret.initFromBits(src);
+    return ret;
+  }
+
+  inline static ET initFromPhysicalDoubles(const double et, const double ettem){
+    ET ret;
+    ret.clear();
+    ret.et = et;
+    ret.ettem = ettem;
+    return ret;
+  }
+
+  inline static ET initFromHWInt(const int et, const int ettem){
+    ET ret;
+    ret.clear();
+    ret.et.V = et;
+    ret.ettem.V = ettem;
+    return ret;
+  }
+}; // struct ET
+
+struct HT{
+  ap_ufixed<12,11> et;
+  ap_uint<13> tower_count;
+  ap_uint<3> spare;
+  ap_uint<4> minimum_bias_hf;
+
+  static const int BITWIDTH = 32;
+
+  inline void clear(){
+    et = 0;
+    tower_count = 0;
+    spare = 0;
+    minimum_bias_hf = 0;
+  }
+
+  inline ap_uint<BITWIDTH> pack() const{
+    ap_uint<BITWIDTH> ret;
+    unsigned int start = 0;
+    pack_into_bits(ret, start, et);
+    pack_into_bits(ret, start, tower_count);
+    pack_into_bits(ret, start, spare);
+    pack_into_bits(ret, start, minimum_bias_hf);
+    return ret;
+  }
+
+  inline void initFromBits(const ap_uint<BITWIDTH> &src){
+    unsigned int start = 0;
+    unpack_from_bits(src, start, et);
+    unpack_from_bits(src, start, tower_count);
+    unpack_from_bits(src, start, spare);
+    unpack_from_bits(src, start, minimum_bias_hf);
+  }
+
+  inline static HT unpack(const ap_uint<BITWIDTH> &src){
+    HT ret;
+    ret.initFromBits(src);
+    return ret;
+  }
+
+  inline static HT initFromPhysicalDoubles(const double et){
+    HT ret;
+    ret.clear();
+    ret.et = et;
+    return ret;
+  }
+
+  inline static HT initFromHWInt(const int et){
+    HT ret;
+    ret.clear();
+    ret.et.V = et;
+    return ret;
+  }
+}; // struct HT
+
+/* ---
+ * Vector Sums
+ * --- */
+struct VectorSumsCommon{
+  ap_ufixed<12,11> et;
+  ap_uint<8> phi;
+  ap_uint<8> asy;
+  ap_uint<4> other;
+
+  static const int BITWIDTH = 32;
+
+  inline void clear(){
+    et = 0;
+    phi = 0;
+    asy = 0;
+    other = 0;
+  }
+
+  inline ap_uint<BITWIDTH> pack() const{
+    ap_uint<BITWIDTH> ret;
+    unsigned int start = 0;
+    pack_into_bits(ret, start, et);
+    pack_into_bits(ret, start, phi);
+    pack_into_bits(ret, start, asy);
+    pack_into_bits(ret, start, other);
+    return ret;
+  }
+
+  inline void initFromBits(const ap_uint<BITWIDTH> &src){
+    unsigned int start = 0;
+    unpack_from_bits(src, start, et);
+    unpack_from_bits(src, start, phi);
+    unpack_from_bits(src, start, asy);
+    unpack_from_bits(src, start, other);
+  }
+
+  inline static VectorSumsCommon unpack(const ap_uint<BITWIDTH> &src){
+    VectorSumsCommon ret;
+    ret.initFromBits(src);
+    return ret;
+  }
+
+  inline static VectorSumsCommon initFromPhysicalDoubles(const double et, const double phi){
+    VectorSumsCommon ret;
+    ret.clear();
+    ret.et = et;
+    ret.phi = round(phi / Scales::CALO_PHI_LSB);
+    return ret;
+  } 
+
+  inline static VectorSumsCommon initFromHWInt(const int et, const int phi){
+    VectorSumsCommon ret;
+    ret.clear();
+    ret.et.V = et;
+    ret.phi.V = phi;
+    return ret;
+  }  
+}; // struct VectorSumsCommon
+
+typedef VectorSumsCommon ETMiss;
+typedef VectorSumsCommon HTMiss;
+typedef VectorSumsCommon ETHFMiss;
+typedef VectorSumsCommon HTHFMiss;
+
+static const int NMUONS = 8;
+static const int NJETS = 12;
+static const int NEGAMMAS = 12;
+static const int NTAUS = 12;
+
+/* ---
+ * Definitions of common objects used for ML triggers
+ * TODO: this is a first implementation, to be improved & expanded
+ * TODO: these data types for px, py, pz are not optimized
+ * --- */
+typedef ap_fixed<18,13> unscaled_t;
+struct PxPyPz{
+
+  unscaled_t px;
+  unscaled_t py;
+  unscaled_t pz;
+
+
+  static const int BITWIDTH = 36;
+
+  inline void clear(){
+    px = 0;
+    py = 0;
+    pz = 0;
+  }
+
+  inline ap_uint<BITWIDTH> pack() const{
+    ap_uint<BITWIDTH> ret;
+    unsigned int start = 0;
+    pack_into_bits(ret, start, px);
+    pack_into_bits(ret, start, py);
+    pack_into_bits(ret, start, pz);
+    return ret;
+  }
+
+  inline void initFromBits(const ap_uint<BITWIDTH> &src){
+    unsigned int start = 0;
+    unpack_from_bits(src, start, px);
+    unpack_from_bits(src, start, py);
+    unpack_from_bits(src, start, pz);
+  }
+
+  inline static PxPyPz unpack(const ap_uint<BITWIDTH> &src){
+    PxPyPz ret;
+    ret.initFromBits(src);
+    return ret;
+  }
+
+  inline static PxPyPz initFromPhysicalDoubles(const double px, const double py, const double pz){
+    PxPyPz ret;
+    ret.clear();
+    ret.px = px;
+    ret.py = py;
+    ret.pz = pz;
+    return ret;
+  }  
+}; // struct PxPyPz
+
+#endif

triggerflow/templates/model-gt.cpp

@@ -0,0 +1,104 @@
+#include "{{MODEL_NAME}}_project.h"
+#include "data_types.h"
+
+namespace {{MODEL_NAME}} {
+
+typedef {{OFFSET_TYPE}} offset_t;
+typedef {{SHIFT_TYPE}}  shift_t;
+
+static const offset_t NN_OFFSETS[{{N_INPUTS}}] = { {{NN_OFFSETS}} };
+static const shift_t  NN_SHIFTS[{{N_INPUTS}}]  = { {{NN_SHIFTS}} };
+
+static void scaleNNInputs(
+    input_t unscaled[{{N_INPUTS}}],
+    input_t scaled[{{N_INPUTS}}]
+) {
+    #pragma HLS pipeline
+    for (int i = 0; i < {{N_INPUTS}}; i++) {
+        #pragma HLS unroll
+        input_t tmp0 = unscaled[i] - NN_OFFSETS[i];
+        input_t tmp1 = tmp0 >> NN_SHIFTS[i];
+        scaled[i] = tmp1;
+    }
+}
+
+void {{MODEL_NAME}}_GT(
+    Muon      muons[{{MUON_SIZE}}],
+    Jet       jets[{{JET_SIZE}}],
+    EGamma    egammas[{{EGAMMA_SIZE}}],
+    Tau       taus[{{TAU_SIZE}}],
+    ET        et,
+    HT        ht,
+    ETMiss    etmiss,
+    HTMiss    htmiss,
+    ETHFMiss  ethfmiss,
+    HTHFMiss  hthfmiss,
+    {{OUTPUT_TYPE}} {{OUTPUT_LAYER}}
+) {
+    #pragma HLS aggregate variable=muons compact=bit
+    #pragma HLS aggregate variable=jets compact=bit
+    #pragma HLS aggregate variable=egammas compact=bit
+    #pragma HLS aggregate variable=taus compact=bit
+    #pragma HLS aggregate variable=et compact=bit
+    #pragma HLS aggregate variable=ht compact=bit
+    #pragma HLS aggregate variable=etmiss compact=bit
+    #pragma HLS aggregate variable=htmiss compact=bit
+    #pragma HLS aggregate variable=ethfmiss compact=bit
+    #pragma HLS aggregate variable=hthfmiss compact=bit
+
+    #pragma HLS array_partition variable=muons complete
+    #pragma HLS array_partition variable=jets complete
+    #pragma HLS array_partition variable=egammas complete
+    #pragma HLS array_partition variable=taus complete
+
+    #pragma HLS pipeline II=1
+    #pragma HLS latency min=2 max=2
+    #pragma HLS inline recursive
+
+    input_t input_unscaled[{{N_INPUTS}}];
+    input_t input_scaled[{{N_INPUTS}}];
+    int idx = 0;
+
+    // Muons
+    for (int i = 0; i < {{MUON_SIZE}}; i++) {
+        #pragma HLS unroll
+        {% for f in MUON_FEATURES %}
+        input_unscaled[idx++] = muons[i].{{f}};
+        {% endfor %}
+    }
+
+    // Jets
+    for (int i = 0; i < {{JET_SIZE}}; i++) {
+        #pragma HLS unroll
+        {% for f in JET_FEATURES %}
+        input_unscaled[idx++] = jets[i].{{f}};
+        {% endfor %}
+    }
+
+    // EGammas
+    for (int i = 0; i < {{EGAMMA_SIZE}}; i++) {
+        #pragma HLS unroll
+        {% for f in EGAMMA_FEATURES %}
+        input_unscaled[idx++] = egammas[i].{{f}};
+        {% endfor %}
+    }
+
+    // Taus
+    for (int i = 0; i < {{TAU_SIZE}}; i++) {
+        #pragma HLS unroll
+        {% for f in TAU_FEATURES %}
+        input_unscaled[idx++] = taus[i].{{f}};
+        {% endfor %}
+    }
+
+    // Scalars / global objects
+    {% for f in GLOBAL_FEATURES %}
+    input_unscaled[idx++] = {{f}};
+    {% endfor %}
+
+    scaleNNInputs(input_unscaled, input_scaled);
+
+    {{MODEL_NAME}}_project(input_scaled, {{OUT}});
+}
+
+} // namespace {{MODEL_NAME}}

{triggerflow-0.2.1.dist-info → triggerflow-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: triggerflow
-Version: 0.2.1
+Version: 0.2.3
 Summary: Utilities for ML models targeting hardware triggers
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -35,22 +35,91 @@ pip install triggerflow
 
 from triggerflow.core import TriggerModel
 
-triggerflow = TriggerModel(name="my-trigger-model", ml_backend="Keras", compiler="hls4ml", model, compiler_config or None)
-triggerflow() # call the constructor
+
+scales = {'offsets': np.array([18, 0, 72, 7, 0, 73, 4, 0, 73, 4, 0, 72, 3, 0, 72, 6, -0, 286, 3, -2, 285, 3, -2, 282, 3, -2, 286, 29, 0, 72, 22, 0, 72, 18, 0, 72, 14, 0, 72, 11, 0, 72, 10, 0, 72, 10, 0, 73, 9, 0], dtype='int'),
+'shifts': np.array([3, 0, 6, 2, 5, 6, 0, 5, 6, 0, 5, 6, -1, 5, 6, 2, 7, 8, 0, 7, 8, 0, 7, 8, 0, 7, 8, 4, 6, 6, 3, 6, 6, 3, 6, 6, 3, 6, 6, 3, 6, 6, 3, 6, 6, 3, 6, 6, 3, 6], dtype='int')}
+
+
+trigger_model = TriggerModel(
+    config="triggermodel_config.yaml",
+    native_model=model, #Native XGboost/Keras model
+    scales=scales
+)
+
+trigger_model() #Vivado requird on $PATH for Firmware build.
 
 # then:
-output_software = triggerflow.software_predict(input_data)
-output_firmware = triggerflow.firmware_predict(input_data)
-output_qonnx = triggerflow.qonnx_predict(input_data)
+output_software = trigger_model.software_predict(input_data)
+output_firmware = trigger_model.firmware_predict(input_data)
+output_qonnx = trigger_model.qonnx_predict(input_data)
 
 # save and load trigger models:
-triggerflow.save("triggerflow.tar.xz")
+trigger_model.save("triggerflow.tar.xz")
 
 # in a separate session:
 from triggerflow.core import TriggerModel
 triggerflow = TriggerModel.load("triggerflow.tar.xz")
 ```
 
+## The Config file:
+
+Use this `.yaml` template and change as needed. 
+
+```yaml
+compiler:
+  name: "AXO"
+  ml_backend: "keras"
+  compiler: "hls4ml"
+  fpga_part: "xc7vx690t-ffg1927-2"
+  clock_period: 25
+  n_outputs: 1
+  project_name: "AXO_project"
+  namespace: "AXO"
+  io_type: "io_parallel"
+  backend: "Vitis"
+  write_weights_txt: false
+
+subsystem:
+  name: "uGT"
+  n_inputs: 50
+  offset_type: "ap_fixed<10,10>"
+  shift_type: "ap_fixed<10,10>"
+
+  objects:
+    muons:
+      size: 4
+      features: [pt, eta_extrapolated, phi_extrapolated]
+
+    jets:
+      size: 4
+      features: [et, eta, phi]
+
+    egammas:
+      size: 4
+      features: [et, eta, phi]
+
+    taus:
+      size: 4
+      features: [et, eta, phi]
+
+  global_features:
+    #- et.et
+    #- ht.et
+    - etmiss.et
+    - etmiss.phi
+    #- htmiss.et
+    #- htmiss.phi
+    #- ethfmiss.et
+    #- ethfmiss.phi
+    #- hthfmiss.et
+    #- hthfmiss.phi
+
+  muon_size: 4
+  jet_size: 4
+  egamma_size: 4
+  tau_size: 4
+```
+
 ## Logging with MLflow
 
 ```python

{triggerflow-0.2.1.dist-info → triggerflow-0.2.3.dist-info}/RECORD

@@ -1,13 +1,15 @@
 trigger_dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trigger_dataset/core.py,sha256=ZX96U6rWxxfCatDQbst6IRZvtlyDj1_2JA7stPydGTQ,2645
 trigger_loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trigger_loader/cluster_manager.py,sha256=n_HgphyNrNzSsCXOnnV02QMd1mR_HLEdlaBy4ClhIF8,3581
-trigger_loader/loader.py,sha256=pLk4KENBGaviZcRuA-XdMQQiNdNU93KBitXx2YbqM8Q,3112
+trigger_loader/cluster_manager.py,sha256=XgmY1xeW8zrpQDJqssKamWzjn6TQ60NGNzpcdZwL6NE,3617
+trigger_loader/loader.py,sha256=wMkeZ3k36wpxt-B8OpKOa6j7z0-fnJUqQ-5AbVjNpBM,5158
 trigger_loader/processor.py,sha256=cvBfYmvcr4FLzOHgGE50oy7EkFzFaV80Z_66amqfsEY,7724
 triggerflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 triggerflow/cli.py,sha256=ZNQb3XQN8Ir6Hp6KX_ugec9bm2kqxLNZ0KdVGJmnqFA,4498
-triggerflow/core.py,sha256=UbmiAIBr_ArVMoFCl26g0PpkgvE1g3Sk9yrzj0XIGcE,21308
+triggerflow/core.py,sha256=QMU_zuWrYXuZekB7z8Q90Cuaga3B_uuDnYOPthQGdps,22465
 triggerflow/mlflow_wrapper.py,sha256=yCaIS-H7oC2KxnExj24ka9ylF4A1wgzRIpc7Y43ervI,10667
+triggerflow/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+triggerflow/interfaces/uGT.py,sha256=UBCK0WtF-MUkI9mWrulOdExtDXgwKPsHDS4C-FXIgMs,3637
 triggerflow/starter/.gitignore,sha256=tH2z_M-tPM9MLWC2wPz1Z43Dq-wdVmb_kVYtrLT3tN4,2052
 triggerflow/starter/README.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 triggerflow/starter/cookiecutter.json,sha256=neplzXvVe3g6OVqYD8M2olfmjRKNr1UKqmflzP3j1UY,259
@@ -86,12 +88,15 @@ triggerflow/starter/{{ cookiecutter.repo_name }}/tests/pipelines/model_training/
 triggerflow/starter/{{ cookiecutter.repo_name }}/tests/pipelines/model_training/test_pipeline.py,sha256=0N747l50lEmjAgCy9K8LrNMW436edMUMo1E7tS4MADY,297
 triggerflow/starter/{{ cookiecutter.repo_name }}/tests/pipelines/model_validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 triggerflow/starter/{{ cookiecutter.repo_name }}/tests/pipelines/model_validation/test_pipeline.py,sha256=2BTupcyuFEXTyMrGLVmF6Yv0CAZcdedc7fxEfmLGmxo,299
+triggerflow/templates/build_ugt.tcl,sha256=P1y42s9Ju6zDyRskCVlD-vSnblAmTafw7Jpzsq4_HWA,1061
+triggerflow/templates/data_types.h,sha256=m7_jLsRixSVjp8auxHZUUNAcSO777C5TTZl__9ENk90,12640
 triggerflow/templates/makefile,sha256=A-aetsLC51Bop0T_-yPY8Z8Hg29ApN4YPvKx_jjPuHw,970
 triggerflow/templates/makefile_version,sha256=6kFc_u2oiM9l2rH7RK_BLzdZu1ZEK8PQTQKGBLRY0v4,328
+triggerflow/templates/model-gt.cpp,sha256=qZwuTtsvrKB_mOB-HDb2uOD7mDo4-20EjFiQzRjMdPo,2969
 triggerflow/templates/model_template.cpp,sha256=jMNRcO7NgC6I9Wd2BV3Bim-P1qPsAl_oeVQ8KofQGEw,1807
 triggerflow/templates/scales.h,sha256=MFcB5S0DEvfzHuUhyZqILR0O4ktugOG-fLnuCDUUewM,373
-triggerflow-0.2.1.dist-info/METADATA,sha256=U4Sh7vfO-SWMUN0a3Yer08Le8R8U7XHLa4vxPMRK7t8,2921
-triggerflow-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-triggerflow-0.2.1.dist-info/entry_points.txt,sha256=5QSV9YDseB_FqgVh9q10BdL4b1I6t68rGwPLXgVL60g,53
-triggerflow-0.2.1.dist-info/top_level.txt,sha256=cX0jkuM9tfxGp002ZBQ1AYgx-6D_NgBtomgPL0WA9bE,43
-triggerflow-0.2.1.dist-info/RECORD,,
+triggerflow-0.2.3.dist-info/METADATA,sha256=8FMEii-KeQD1cm7c2ZrpHI-4f-efE9DmrlP4H9VzmxQ,4353
+triggerflow-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+triggerflow-0.2.3.dist-info/entry_points.txt,sha256=5QSV9YDseB_FqgVh9q10BdL4b1I6t68rGwPLXgVL60g,53
+triggerflow-0.2.3.dist-info/top_level.txt,sha256=cX0jkuM9tfxGp002ZBQ1AYgx-6D_NgBtomgPL0WA9bE,43
+triggerflow-0.2.3.dist-info/RECORD,,