atropy-core 0.0.1__tar.gz

atropy_core-0.0.1/.clang-format

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

atropy_core-0.0.1/.git

@@ -0,0 +1 @@
+gitdir: ../../.git/modules/atropy/core

atropy_core-0.0.1/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_core-0.0.1/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: atropy_core
+Version: 0.0.1
+Summary: Scripts for generating input files and plotting output files
+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>
+Requires-Python: >=3.10

atropy_core-0.0.1/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")

atropy_core-0.0.1/atropy_core/examples/boolean/set_apoptosis.py

@@ -0,0 +1,158 @@
+"""Script for setting the initial conditions for the Boolean apoptosis model."""
+
+import argparse
+import sys
+
+import numpy as np
+
+import atropy_core.boolean_helper
+from atropy_core.grid import GridParms
+from atropy_core.index_functions import incrVecIndex
+from atropy_core.initial_condition import InitialCondition
+from atropy_core.tree import Tree
+
+reaction_system = atropy_core.boolean_helper.convertRulesToReactions(
+    "atropy_core/examples/models/boolean/apoptosis.hpp"
+)
+
+p_best = (
+    "((0 2 3 4 5 6 7 8 9 12 20)(21 25 26 27 28 29 30 31 39 40))"
+    "((1 10 11 14 15 22 23 32 33 38)(13 16 17 18 19 24 34 35 36 37))"
+)
+p_worst = (
+    "((0 1 4 7 11 12 14 16 23 33 34)(2 3 5 8 13 19 20 24 32 35))"
+    "((6 9 15 17 21 22 25 26 31 37)(10 18 27 28 29 30 36 38 39 40))"
+)
+p_reasonable = (
+    "((0 2 3 4 5 6 7 8 12 20)(1 9 10 11 14 15 16 17 22 23))"
+    "((13 18 19 24 32 33 34 35 36 37 38)(21 25 26 27 28 29 30 31 39 40))"
+)
+
+parser = argparse.ArgumentParser(
+    prog="set_apoptosis",
+    usage="python3 atropy_core/examples/boolean/set_apoptosis.py --partition_best --rank 5",
+    description="This script sets initial conditions for the apoptosis model.",
+)
+
+parser.add_argument(
+    "-pb",
+    "--partition_best",
+    action="store_const",
+    const=p_best,
+    required=False,
+    help="Set the partition string to the best partition in terms of entropy",
+    dest="partition",
+)
+
+parser.add_argument(
+    "-pw",
+    "--partition_worst",
+    action="store_const",
+    const=p_worst,
+    required=False,
+    help="Set the partition string to the worst partition w.r.t. entropy",
+    dest="partition",
+)
+
+parser.add_argument(
+    "-pr",
+    "--partition_reasonable",
+    action="store_const",
+    const=p_reasonable,
+    required=False,
+    help="Set the partition string to the best partition w.r.t. Kerninghan-Lin counts",
+    dest="partition",
+)
+
+parser.add_argument(
+    "-p",
+    "--partition",
+    type=str,
+    required=False,
+    help="Specify a general partition string",
+    dest="partition",
+)
+
+parser.add_argument(
+    "-r",
+    "--rank",
+    type=int,
+    required=True,
+    help="Specify the ranks of the internal nodes",
+)
+args = parser.parse_args()
+
+if args.partition is None:
+    print("usage:", parser.usage)
+    print(
+        parser.prog + ":",
+        """
+          error: one of the following arguments is required:
+          -p/--partition`,
+          -pb/--partition_best,
+          -pw/--partition_worst,
+          -pr/--partition_reasonable,
+          """,
+    )
+    sys.exit(1)
+
+partition_str = args.partition
+
+# Grid parameters
+d = 41
+n = 2 * np.ones(d, dtype=int)
+binsize = np.ones(d, dtype=int)
+liml = np.zeros(d)
+grid = GridParms(n, binsize, liml)
+
+# Set up the partition tree
+tree = Tree(partition_str, grid)
+
+r_out = np.ones(tree.n_internal_nodes, dtype="int") * args.rank
+n_basisfunctions = np.ones(r_out.size, dtype="int")
+tree.initialize(reaction_system, r_out)
+
+
+def eval_x(x: np.ndarray, grid: GridParms):
+    result = 1.0 / grid.dx()
+    pos0 = np.argwhere(grid.species == 0)  # TNF
+    pos1 = np.argwhere(grid.species == 1)  # GF
+    pos40 = np.argwhere(grid.species == 40)  # DNAdam
+    if pos0.size > 0:
+        result *= 1.0 if x[pos0] == 1 else 0.0
+    if pos1.size > 0:
+        result *= 1.0 if x[pos1] == 1 else 0.0
+    if pos40.size > 0:
+        result *= 1.0 if x[pos40] == 0 else 0.0
+    return result
+
+
+# Low-rank initial conditions
+initial_conditions = InitialCondition(tree, n_basisfunctions)
+
+for Q in initial_conditions.Q:
+    Q[0, 0, 0] = 1.0
+
+for n_node in range(tree.n_external_nodes):
+    vec_index = np.zeros(initial_conditions.external_nodes[n_node].grid.d())
+    for i in range(initial_conditions.external_nodes[n_node].grid.dx()):
+        initial_conditions.X[n_node][i, :] = eval_x(
+            vec_index, initial_conditions.external_nodes[n_node].grid
+        )
+        incrVecIndex(
+            vec_index,
+            initial_conditions.external_nodes[n_node].grid.n,
+            initial_conditions.external_nodes[n_node].grid.d(),
+        )
+
+# Calculate norm
+_, marginal_distribution = tree.calculateObservables(
+    np.zeros(tree.root.grid.d(), dtype="int")
+)
+norm = np.sum(marginal_distribution[tree.species_names[0]])
+print("norm:", norm)
+tree.root.Q[0, 0, 0] /= norm
+
+# Print tree and write it to a netCDF file
+print(tree)
+tree.write()

atropy_core-0.0.1/atropy_core/examples/boolean/set_pancreatic_cancer.py

@@ -0,0 +1,158 @@
+"""Script for setting the initial conditions for the Boolean pancreatic cancer model."""
+
+import argparse
+import sys
+
+import numpy as np
+
+import atropy_core.boolean_helper
+from atropy_core.grid import GridParms
+from atropy_core.index_functions import incrVecIndex
+from atropy_core.initial_condition import InitialCondition
+from atropy_core.tree import Tree
+
+reaction_system = atropy_core.boolean_helper.convertRulesToReactions(
+    "atropy_core/examples/models/boolean/pancreatic_cancer.hpp"
+)
+
+p_best = (
+    "((0 1 2 3 4 5 6 9 12)(7 8 10 11 17 21 23 26))"
+    "((13 14 19 20 22 27 28 31 33)(15 16 18 24 25 29 30 32))"
+)
+p_worst = (
+    "((0 1 2 4 8 11 17 26)(3 5 6 7 9 10 12 21 23))"
+    "((13 18 19 20 22 25 31 33)(14 15 16 24 27 28 29 30 32))"
+)
+p_reasonable = (
+    "((0 1 2 3 4 5 7 9)(13 14 19 20 25 27 29 30 32))"
+    "((6 10 12 16 18 21 24 26 31)(8 11 15 17 22 23 28 33))"
+)
+
+parser = argparse.ArgumentParser(
+    prog="set_pancreatic",
+    usage="python3 atropy_core/examples/boolean/set_pancreatic_cancer.py --partition_best --rank 5",
+    description="This script sets initial conditions for the pancreatic cancer model.",
+)
+
+parser.add_argument(
+    "-pb",
+    "--partition_best",
+    action="store_const",
+    const=p_best,
+    required=False,
+    help="Set the partition string to the best partition in terms of entropy",
+    dest="partition",
+)
+
+parser.add_argument(
+    "-pw",
+    "--partition_worst",
+    action="store_const",
+    const=p_worst,
+    required=False,
+    help="Set the partition string to the worst partition w.r.t. entropy",
+    dest="partition",
+)
+
+parser.add_argument(
+    "-pr",
+    "--partition_reasonable",
+    action="store_const",
+    const=p_reasonable,
+    required=False,
+    help="Set the partition string to the best partition w.r.t. Kerninghan-Lin counts",
+    dest="partition",
+)
+
+parser.add_argument(
+    "-p",
+    "--partition",
+    type=str,
+    required=False,
+    help="Specify a general partition string",
+    dest="partition",
+)
+
+parser.add_argument(
+    "-r",
+    "--rank",
+    type=int,
+    required=True,
+    help="Specify the ranks of the internal nodes",
+)
+args = parser.parse_args()
+
+if args.partition is None:
+    print("usage:", parser.usage)
+    print(
+        parser.prog + ":",
+        """
+          error: one of the following arguments is required:
+          -p/--partition`,
+          -pb/--partition_best,
+          -pw/--partition_worst,
+          -pr/--partition_reasonable,
+          """,
+    )
+    sys.exit(1)
+
+partition_str = args.partition
+
+# Grid parameters
+d = 34
+n = 2 * np.ones(d, dtype=int)
+binsize = np.ones(d, dtype=int)
+liml = np.zeros(d)
+grid = GridParms(n, binsize, liml)
+
+# Set up the partition tree
+tree = Tree(partition_str, grid)
+
+r_out = np.ones(tree.n_internal_nodes, dtype="int") * args.rank
+n_basisfunctions = np.ones(r_out.size, dtype="int")
+tree.initialize(reaction_system, r_out)
+
+
+def eval_x(x: np.ndarray, grid: GridParms):
+    result = 1.0 / grid.dx()
+    # pos0 = np.argwhere(grid.species==0) # HMGB
+    # pos4 = np.argwhere(grid.species==4) # RAS
+    # pos25 = np.argwhere(grid.species==25) # P54
+    # if pos0.size > 0:
+    #     result *= (1.0 if x[pos0] == 1 else 0.0)
+    # if pos4.size > 0:
+    #     result *= (1.0 if x[pos4] == 1 else 0.0)
+    # if pos25.size > 0:
+    #     result *= (1.0 if x[pos25] == 0 else 0.0)
+    return result
+
+
+# Low-rank initial conditions
+initial_conditions = InitialCondition(tree, n_basisfunctions)
+
+for Q in initial_conditions.Q:
+    Q[0, 0, 0] = 1.0
+
+for n_node in range(tree.n_external_nodes):
+    vec_index = np.zeros(initial_conditions.external_nodes[n_node].grid.d())
+    for i in range(initial_conditions.external_nodes[n_node].grid.dx()):
+        initial_conditions.X[n_node][i, :] = eval_x(
+            vec_index, initial_conditions.external_nodes[n_node].grid
+        )
+        incrVecIndex(
+            vec_index,
+            initial_conditions.external_nodes[n_node].grid.n,
+            initial_conditions.external_nodes[n_node].grid.d(),
+        )
+
+# Calculate norm
+_, marginal_distribution = tree.calculateObservables(
+    np.zeros(tree.root.grid.d(), dtype="int")
+)
+norm = np.sum(marginal_distribution[tree.species_names[0]])
+print("norm:", norm)
+tree.root.Q[0, 0, 0] /= norm
+
+# Print tree and write it to a netCDF file
+print(tree)
+tree.write()