atropy 0.0.1__tar.gz

atropy-0.0.1/.gitignore

@@ -0,0 +1,18 @@
+.cache
+.DS_STORE
+.pytest_cache/
+.ruff_cache/
+.vscode/
+__pycache__
+*.egg-info
+*.npy
+*.npz
+*.out
+bin/
+build/
+input/
+output/
+plots/
+Testing/
+profiling/
+CMakeFiles

atropy-0.0.1/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "atropy/core"]
+	path = atropy/core
+	url = git@gitlab.com:atropy/atropos.git

atropy-0.0.1/.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+    -   id: check-executables-have-shebangs
+    -   id: check-added-large-files
+        args: [--maxkb, "5000"]
+    -   id: check-yaml
+    -   id: check-toml
+    -   id: check-merge-conflict
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+        # exclude markdown files
+        exclude: '.*\.md'
+-   repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.6.4
+    hooks:
+    # run the linter
+    -   id: ruff
+        args: [ --fix ]
+    # run the formatter
+    -   id: ruff-format
+-   repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v18.1.8
+    hooks:
+    -   id: clang-format
+        types_or: [c++, c, cuda]

atropy-0.0.1/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2024 Julian Mangott, Lukas Einkemmer, Martina Prugger, Stefan Brunner
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

atropy-0.0.1/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.2
+Name: atropy
+Version: 0.0.1
+Summary: Wrapper for the atropy_core C++ library
+Author-Email: Julian Mangott <julian.mangott@uibk.ac.at>, Lukas Einkemmer <lukas.einkemmer@uibk.ac.at>, Martina Prugger <martina.prugger@ipp.mpg.de>, Stefan Brunner <stefan.brunner@student.uibk.ac.at>
+License: MIT License
+         Copyright (c) 2024 Julian Mangott, Lukas Einkemmer, Martina Prugger, Stefan Brunner
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+         
+Project-URL: Homepage, https://stefanbrunner2709.github.io/kinetic-cme/
+Project-URL: GitLab, https://git.uibk.ac.at/c7021158/kinetic-cme
+Requires-Python: >=3.10
+Requires-Dist: atropy_core
+Requires-Dist: netCDF4
+Requires-Dist: networkx
+Requires-Dist: numba==0.60.0
+Requires-Dist: numpy==1.26.4
+Requires-Dist: matplotlib
+Requires-Dist: regex
+Requires-Dist: scipy
+Requires-Dist: xarray==2024.9.0
+Requires-Dist: xarray-datatree
+Requires-Dist: sympy
+

atropy-0.0.1/README.md

@@ -0,0 +1,186 @@
+---
+title: "README"
+author: [Julian Mangott]
+date: "2025-02-02"
+keywords: [Markdown, README]
+disable-header-and-footer: true
+pagestyle: empty
+header-includes:
+  - \usepackage{bm}
+---
+
+# DLR approximation for the kinetic CME
+
+- [DLR approximation for the kinetic CME](#dlr-approximation-for-the-kinetic-cme)
+  - [Objective](#objective)
+  - [Requirements](#requirements)
+  - [Installation](#installation)
+    - [Intel MKL](#intel-mkl)
+    - [OpenMP](#openmp)
+    - [Python environment](#python-environment)
+  - [Run the program](#run-the-program)
+  - [Input](#input)
+    - [Preparing input data](#preparing-input-data)
+  - [Output](#output)
+  - [Example problems](#example-problems)
+  - [References](#references)
+
+## Objective
+`atropy` solves the chemical master equation (CME),
+$$\partial_t{P}(t,\mathbf{x}) = \sum_{\mu = 0}^{M-1}\left(\alpha_\mu(\mathbf{x}-\bm{\nu}_\mu)P(t,\mathbf{x}-\bm{\nu}_\mu) - \alpha_\mu(\mathbf{x})P(t,\mathbf{x})\right)$$
+
+according to the algorithm proposed in https://arxiv.org/abs/2407.11792, which is based on the projector-splitting integrator for Tree Tensor networks \[1\].
+
+$P(t,\mathbf{x})\,\mathrm{d}t$ is the probability of finding a population number of $\mathbf{x} = (x_0, \dots, x_{N-1})$ molecules of species $S_0, \dots, S_{N-1}$ in the time interval $[t,\,t + \mathrm{d}t]$.
+The CME describes the time evolution of this probability distribution $P(t,\mathbf{x})$ in a chemical reaction network with $N$ different species $S_0, \dots, S_{N-1}$, which can react via $M$ reaction channels $R_0, \dots, R_{M-1}$. For a given reaction $\mu$, the stoichiometric vector $\bm{\nu}_\mu$ denotes the population change by that reaction and the propensity functions $\alpha_\mu(\mathbf{x})$ and $\alpha_\mu(\mathbf{x}-\bm{\nu}_\mu)$ are proportional to the transition probabilities $T(\mathbf{x}+\bm{\nu}_\mu|\mathbf{x})$ and $T(\mathbf{x}|\mathbf{x}-\bm{\nu}_\mu)$.
+
+`atropy` makes use of the low-rank framework `Ensign` \[2\].
+
+## Requirements
+- CMake (3.22.1 or later)
+- C++20 compatible C++ compiler
+- Eigen 3.4 (if the implicit Euler or Crank-Nicolson integrators are used)
+- Fortran compiler (if OpenBLAS is used)
+- HDF5 (1.10.x)
+- netCDF4
+- Python (>3.8)
+- OpenMP (optional)
+- Intel MKL (optional)
+
+Check via `nc-config --has-hdf5`, whether HDF5 was used in the netCDF4 build.
+
+## Installation
+Build the program in the project root by executing
+```shell
+cmake -B <build> -DCMAKE_BUILD_TYPE=Release
+cmake --build <build>
+```
+
+The generated executable `atropy` can be found in `bin`.
+
+To enable compiler options for debugging, use `-DCMAKE_BUILD_TYPE=Debug` instead.
+Unit tests for C++ files are provided in the `tests` folder. They can be run with 
+```shell
+ctest --test-dir <build>
+```
+
+MacOS: pybind11 might not find the `Python.h` header during the CMake build process.
+In that case, set `export CPLUS_INCLUDE_PATH=<path/to/python/include>` accordingly.
+
+### Intel MKL
+If you prefer to use Intel MKL as the BLAS and LAPACK backend instead of OpenBLAS set 
+```shell
+export MKLROOT=/path/to/intel/mkl
+cmake -B <build> -DCMAKE_BUILD_TYPE=Release -DMKL_ENABLED=ON
+cmake --build <build>
+```
+and make sure to add the MKL libraries to your `LD_LIBRARY_PATH`, i.e.
+```shell
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/intel/mkl/lib/intel64_lin/
+```
+before running the executable.
+
+### OpenMP
+OpenMP can be activated via
+```shell
+cmake -B <build> -DCMAKE_BUILD_TYPE=Release -DOPENMP=ON
+```
+Make sure that the `OMP_NUM_THREADS` environment variable is in accordance with your hardware specification and run the unit tests via 
+```shell
+ctest --test-dir <build>
+```
+to ensure that OpenMP and `atropy` work correctly.
+
+MacOS: Note that XCode compilers do not support OpenMP. For using OpenMP on macOS, a manual installation (e.g. of `gcc11`) is required and the `CXX`, `CC` and `FC` environment variables have to be set accordingly.
+
+### Python environment
+To use the Python notebooks and programs included in `scripts`, a Python environment with external packages specified in `pip-requirements.txt` needs to be configured and enabled.
+For Python venv:
+```shell
+python -m venv path/to/my_venv
+source path/to/my_venv/bin/activate
+pip install -r pip-requirements.txt
+pip install -e .
+```
+For anaconda:
+```shell
+conda create -n my_venv python --file pip-requirements.txt
+conda activate my_venv
+pip install -e .
+```
+All scripts and notebooks have to be executed from the project root. When using a IDE, make sure to adjust the settings accordingly. In Microsoft Visual Studio Code one has to set the "Notebook File Root" to `{workspaceFolder}` to run the notebooks.
+Unit tests for Python files are located in the `scripts/tests` folder. They can be run in the Python environment via
+```shell
+pytest scripts/tests
+```
+
+## Run the program
+`atropy` has to be run with
+```
+  ./bin/atropy [OPTION...]
+```
+and expects the following command line arguments:
+- `-i`, `--input`: Name of the input .nc file (default: `input/input.nc`)
+- `-o`, `--output`: Name of the output folder, stored in `output/`
+- `-s`, `--snapshot`: Number of steps between two snapshots
+- `-t`, `--tau`: Time step size
+- `-f`, `--tfinal`: Final integration time
+- `-n`, `--substeps`: Number of integration substeps (default: `1`)
+- `-m`, `--method`: Integration method (`e` (explicit Euler), `r` (explicit RK4), `i` 
+                      (implicit Euler), `c` (Crank-Nicolson)) (default: `i`)
+- `-h`, `--help`: Print usage
+
+## Input
+Input netCDF files have to be stored as `input/input.nc` (the directory can be changed using the `-i` flag) and can be generated with the input scripts provided in `scripts/input_generation`.
+
+**Caution:** As `Ensign` stores arrays in column-major (Fortran) order, it is assumed that input arrays also follow this convention.
+<!-- TODO: Give more detais -->
+
+<!-- TODO: ### Binning -->
+
+### Preparing input data
+Let us consider the input script `set_lambda_phage.py` located in the `scripts/input_generation` folder, which generates input data for the lambda phage model. It gives an example on how the initial conditions have to be set up. The `input/input.nc` file is generated via
+```shell
+python3 scripts/input_generation/set_lamba_phage.py --partition "(0 1)((2 3)(4))" --rank 5 4
+```
+and a short documentation for this script is provided by
+```shell
+python3 scripts/input_generation/set_lambda_phage.py --help
+```
+<!-- TODO: ### Describe examples in more detail -->
+
+Note that `atropy` assumes that the propensity function is factorizable for the species in different partitions. However, the input scripts rely on the `ReactionSystem` class (cf. `scripts/reaction_class.py`), which assumes that the propensity function is factorizable in *all* species. This is a valid assumption for most scenarios. For problems where species in a partition are not factorizable, the propensity function can be adjusted manually after initializing the `Tree` with the method `initialize`.
+
+<!-- #### Writing a model file with the `ReactionSystem` class
+The model file contains all reactions $`R_\mu`$ ($`\mu=1,\dots,M`$) of the specific problem and has to be imported in the input scripts. -->
+
+<!-- TODO: More detailed description. -->
+
+
+## Output
+`atropy` automatically creates a folder in `output/` with a name set by the `-o`/`--output` parameter.
+The low-rank factors and coupling coefficients as well as the chosen model parameters are stored in this folder as `output_t<ts>.nc` (`<ts>` denotes the time step) in intervals according to the `-s`/`--snapshot` parameter.
+
+<!-- TODO: Describe the structure of the .netCDF file -->
+
+## Example problems
+Input generation scripts for the example problems (lambda phage and reaction cascade) are provided in `scripts/input_generation` and the corresponding model files can be found in `scripts/models`.
+
+All required output files and reference solutions for reproducing the plots in https://arxiv.org/abs/2407.11792 can be computed with the shell scripts provided in `scripts/shell`. Before generating the plots with the interactive Python notebooks provided in `scripts/output/notebooks`, a `plots` folder has to be created in the project root:
+```shell
+mkdir plots
+```
+Then, for the lambda phage example one has to run
+```shell
+sh scripts/shell/run_lambda_phage.sh
+```
+and for the cascade reaction example
+```shell
+sh scripts/shell/run_cascade.sh
+```
+
+## References
+\[1\]: Ceruti, G., Lubich, C., and Walach, H.: Time integration of Tree Tensor networks", SIAM J. Numer. Anal. **59** (2021)
+<!-- Lubich, C., Oseledets, I.: "A projector-splitting integrator for dynamical low-rank approximation", BIT Numerical Mathematics **54** (2014) -->
+
+\[2\]: Cassini, F., and Einkemmer, L.: "Efficient 6D Vlasov simulation using the dynamical low-rank framework Ensign", Comp. Phys. Comm. **280** (2022)

atropy-0.0.1/atropy/core/.clang-format

@@ -0,0 +1,8 @@
+---
+BasedOnStyle: LLVM
+BreakBeforeBraces: Stroustrup
+ColumnLimit: '88'
+DerivePointerAlignment: 'false'
+IndentWidth: '4'
+Language: Cpp
+PointerAlignment: Left

atropy-0.0.1/atropy/core/CMakeLists.txt

@@ -0,0 +1,187 @@
+cmake_minimum_required(VERSION 3.27 FATAL_ERROR)
+project(atropy_core
+        VERSION 0.0.1
+        DESCRIPTION "Dynamical low-rank solver for the kinetic CME"
+        HOMEPAGE_URL https://git.uibk.ac.at/c7021158/kinetic-cme
+        LANGUAGES CXX)
+enable_testing()
+
+include(FetchContent)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake-modules")
+set(CMAKE_CONFIGURATION_TYPES "Debug;Release;Profile" CACHE STRING "" FORCE)
+
+
+################################################################################
+# General options
+################################################################################
+
+option("MKL_ENABLED" "Enable MKL for Ensign" OFF)
+option("OPENMP" "Enable OpenMP" OFF)
+option("PYBIND11_ENABLED" "Enable PYBIND" OFF)
+
+
+################################################################################
+# Compiler options
+################################################################################
+
+if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+    set(CMAKE_CXX_FLAGS         
+      "${CMAKE_CXX_FLAGS} -Warn all -fpic"
+    )
+    set(CMAKE_CXX_FLAGS_DEBUG
+      "-g -check all -traceback"
+    )
+    set(CMAKE_CXX_FLAGS_RELEASE
+      "-O3 -ip -xHOST"
+    )
+
+else(CMAKE_CXX_COMPILER_ID MATCHES GNU)
+    set(CMAKE_CXX_FLAGS
+      "${CMAKE_CXX_FLAGS} -Wall -fPIC"
+    )
+    set(CMAKE_CXX_FLAGS_DEBUG
+      "-O0 -g3 -ggdb3 -Wall -D_GLIBCXX_DEBUG -fno-omit-frame-pointer -ftrapv"
+    )
+    set(CMAKE_CXX_FLAGS_RELEASE
+      "-O3 -DNDEBUG -march=native -mtune=native"
+    )
+endif()
+
+
+################################################################################
+# External libraries
+################################################################################
+
+################################################################################
+# Eigen
+
+find_package(Eigen3 3.4 REQUIRED NO_MODULE)
+
+
+################################################################################
+# NetCDF
+
+find_package(NetCDF REQUIRED)
+
+
+################################################################################
+# cxxopts
+
+FetchContent_Declare(cxxopts
+  GIT_REPOSITORY "https://github.com/jarro2783/cxxopts.git"
+  GIT_TAG "v3.2.1"
+  GIT_SHALLOW ON
+  GIT_PROGRESS ON
+  FIND_PACKAGE_ARGS
+)
+FetchContent_MakeAvailable(cxxopts)
+
+
+################################################################################
+# Ensign
+
+FetchContent_Declare(Ensign
+  GIT_REPOSITORY https://github.com/leinkemmer/Ensign.git
+  GIT_TAG "development"
+  GIT_SHALLOW ON
+  GIT_PROGRESS ON
+  FIND_PACKAGE_ARGS
+)
+FetchContent_MakeAvailable(Ensign)
+
+
+################################################################################
+# pybind 11
+
+if (PYBIND11_ENABLED)
+  set(PYBIND11_NEWPYTHON ON)
+  find_package(pybind11 REQUIRED)
+endif()
+
+
+################################################################################
+# Create short-hands
+################################################################################
+
+# Create `input` and `output` directories
+file(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/input)
+file(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/output)
+
+# Define short-hands for the src directory and the files
+set(SRC ${CMAKE_CURRENT_SOURCE_DIR}/src)
+set(SRC_FILES ${SRC}/bug_integrator.cpp
+              ${SRC}/grid_class.cpp
+              ${SRC}/matrix.cpp
+              ${SRC}/print_functions.cpp
+              ${SRC}/ps_integrator.cpp
+              ${SRC}/tree_class.cpp)
+set(HDR_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+
+################################################################################
+# Set up the program
+################################################################################
+
+if(PYBIND11_ENABLED)
+
+  ################################################################################
+  # pybind11
+
+  pybind11_add_module(atropy_core_pybind11
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp
+    ${SRC_FILES}
+  )
+
+  # Add SOURCE_ROOT as a preprocessor directive
+  target_compile_definitions(atropy_core_pybind11
+    PRIVATE "SOURCE_ROOT=${CMAKE_CURRENT_SOURCE_DIR}"
+  )
+
+  target_compile_definitions(atropy_core_pybind11 PRIVATE "__PYBIND11__")
+
+  target_include_directories(atropy_core_pybind11 PRIVATE ${HDR_DIR})
+  target_link_libraries(atropy_core_pybind11 PRIVATE Ensign::Ensign)
+  target_link_libraries(atropy_core_pybind11 PUBLIC Eigen3::Eigen)
+  target_include_directories(atropy_core_pybind11 PRIVATE ${NETCDF_INCLUDE_DIR})
+
+  if(cxxopts_FOUND)
+    target_link_libraries(atropy_core_pybind11 PRIVATE cxxopts::cxxopts)
+  else()
+    target_link_libraries(atropy_core_pybind11 PRIVATE cxxopts)
+  endif()
+
+  install(TARGETS atropy_core_pybind11 LIBRARY DESTINATION .)
+
+else()
+
+  ################################################################################
+  # atropy_core
+
+  add_executable(${PROJECT_NAME}
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp
+    ${SRC_FILES}
+  )
+
+  # Add SOURCE_ROOT as a preprocessor directive
+  target_compile_definitions(${PROJECT_NAME}
+    PRIVATE "SOURCE_ROOT=${CMAKE_CURRENT_SOURCE_DIR}"
+  )
+
+  target_include_directories(${PROJECT_NAME} PRIVATE ${HDR_DIR})
+  target_link_libraries(${PROJECT_NAME} PRIVATE Ensign::Ensign)
+  target_link_libraries(${PROJECT_NAME} PUBLIC Eigen3::Eigen)
+  target_include_directories(${PROJECT_NAME} PRIVATE ${NETCDF_INCLUDE_DIR})
+
+  if(cxxopts_FOUND)
+    target_link_libraries(${PROJECT_NAME} PRIVATE cxxopts::cxxopts)
+  else()
+    target_link_libraries(${PROJECT_NAME} PRIVATE cxxopts)
+  endif()
+
+  if(BUILD_TESTING)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tests)
+  endif()
+endif()

atropy-0.0.1/atropy/core/atropy_core/boolean_helper.py

@@ -0,0 +1,133 @@
+"""Helper module for Boolean reaction models."""
+
+import ctypes
+import inspect
+import subprocess
+import tempfile
+import textwrap
+
+import bitarray
+import bitarray.util
+import numpy as np
+import regex as re
+
+import atropy_core.reaction
+
+
+def convertRulesToReactions(filename: str):
+    """
+    Converts a rule file of the Boolean CME integrator of
+    https://bitbucket.org/mprugger/low_rank_cme to a `ReactionSystem` instance.
+    NOTE: This method is only capable of converting systems
+    with a maximum of 64 species.
+    """
+    with open(filename) as f:
+        line0 = f.readline()
+        f_string = f.read()
+
+    match = re.match(r"RULE_SET\((.*)\)", line0)
+    model_info = [x.split()[0] for x in match.group(1).split(",")]
+
+    model_name = model_info[0]
+    d = int(model_info[1])
+    species_names = [name[1:-1] for name in model_info[2:]]
+
+    rules = {}
+    dependencies = {}
+
+    rule_pattern = (
+        f"template<> bool {model_name}::rule<(\d+)>\(bitset<{d}> x\) " "\{([\S\s]*?)\}"
+    )
+    dependency_pattern = (
+        f"template<> vector<ind> {model_name}::depends_on<(\d+)>\(\) "
+        "\{[\s]*?return \{(.*?)\};\s*\}"
+    )
+
+    rule_matches = re.finditer(rule_pattern, f_string, re.MULTILINE)
+    for _, match in enumerate(rule_matches, start=1):
+        i = int(match.group(1))
+        rules[i] = match.group(2)
+
+    dependency_matches = re.finditer(dependency_pattern, f_string, re.MULTILINE)
+    for _, match in enumerate(dependency_matches, start=1):
+        i = int(match.group(1))
+        dependency = [int(d) for d in match.group(2).split(",")]
+        if i not in dependency:
+            dependency.append(i)
+        dependencies[i] = sorted(dependency)
+
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        with open(tmpdirname + "/rule_set_temp.cpp", mode="w") as f:
+            str_begin = '#include <bitset>\nextern "C"\n{'
+            f.write(str_begin)
+            for k, v in rules.items():
+                str_rule = "\n\tbool rule_{}(std::bitset<{}> x)\n\t{{{}\t}}\n"
+                f.write(str_rule.format(k, d, textwrap.indent(v, "\t")))
+            str_end = "}"
+            f.write(str_end)
+
+        subprocess.run(
+            [
+                "g++",
+                "-fPIC",
+                "-shared",
+                "-o",
+                tmpdirname + "/rule_set_temp.so",
+                tmpdirname + "/rule_set_temp.cpp",
+            ]
+        )
+
+        handle = ctypes.CDLL(tmpdirname + "/rule_set_temp.so")
+
+    def fun_x0(x):
+        return 1 - x
+
+    def fun_x1(x):
+        return x
+
+    reactions = []
+
+    for i in range(d):
+        d_dep = len(dependencies[i])
+        dx_dep = 2**d_dep
+        for j in range(dx_dep):
+            x = bitarray.bitarray(d, endian="little")
+            x.setall(0)
+            x_dep = bitarray.util.int2ba(j, length=d_dep, endian="little")
+            for k, k_dep in enumerate(dependencies[i]):
+                x[k_dep] = x_dep[k]
+            curr_rule = handle[f"rule_{i}"]
+            curr_rule.argtypes = [
+                ctypes.c_ulonglong
+            ]  # avoid overflow for large systems
+            x_i_prime = curr_rule(bitarray.util.ba2int(x))
+            if (
+                x[i] != x_i_prime
+            ):  # create a reaction only when output is different from input
+                nu = np.zeros(d)
+                nu[i] = 1 if x[i] == 0 else -1
+                propensity = {}
+                for k_dep in dependencies[i]:
+                    propensity[k_dep] = fun_x0 if x[k_dep] == 0 else fun_x1
+                reactions.append(atropy_core.reaction.Reaction(propensity, nu))
+
+    reaction_system = atropy_core.reaction.ReactionSystem(reactions, species_names)
+
+    return reaction_system
+
+
+if __name__ == "__main__":
+    import numpy as np
+
+    reaction_system = convertRulesToReactions(
+        "atropy_core/examples/models/boolean/pancreatic_cancer.hpp"
+    )
+
+    func_pattern = re.compile(r"return (.+)\\n")
+    for mu, reaction in enumerate(reaction_system.reactions):
+        print(f"reaction {mu}, product {int(np.nonzero(reaction.nu)[0])}")
+        for k, v in reaction.propensity.items():
+            func_string = str(inspect.getsourcelines(v)[0])
+            func = re.findall(func_pattern, func_string)
+            print(k, func)
+        print(reaction.nu, "\n")