Summary

The DAGModelling software is a python implementation of the dataflow programming with the lazy graph evaluation approach.

Main goals:

• Lazy evaluated directed acyclic graph;
• Concise connection syntax;
• Plotting with graphviz;
• Flexibility. The goal of DAG-Modelling is not to be efficient, but rather flexible.

The framework is intended to be used for the statistical analysis of the data of JUNO and Daya Bay neutrino oscillation experiments.

Installation

For users (recommended)

For regular use, it's best to install the latest version of the project that's available on PyPi:

pip install dag-modelling

For developers

We recommend that developers install the package locally in editable mode:

git clone https://github.com/dagflow-team/dag-modelling.git
cd dag-modelling
pip install -e .

This way, the system will track all the changes made to the source files. This means that developers won't need to reinstall the package or set environment variables, even when a branch is changed.

Cython acceleration (optional)

Building

Compilation is opt-in: pip install dag-modelling (and pip install .) gives pure Python. To build the .so extensions, install Cython first and disable build isolation, otherwise the build does not see it:

pip install cython
pip install --no-build-isolation ".[cython]"                              # from a checkout
pip install --no-build-isolation --no-binary dag-modelling dag-modelling  # from PyPI

The cython extra alone does not compile anything. From PyPI, --no-binary is needed too, since the published wheel is pure Python.

When editing .pyx sources, rebuild in place:

python setup.py build_ext --inplace

Three files per compiled class

At import time Python prefers the compiled x.<abi>.so over x.py, so from dag_modelling.core.node import Node works either way.

Switching to pure Python

Set DGM_DISABLE_CYTHON=1 to use the .py core even when .so files are built, e.g. to run tests in both modes:

pytest                         # compiled core (if built)
DGM_DISABLE_CYTHON=1 pytest    # pure-Python core

The variable is read on the first import dag_modelling, so a running process cannot switch. To check which core is loaded, look at dag_modelling.core.node_eval.__file__ (.so or .py).

Example

For example, let's consider a sum of three input nodes and then a product of the result with another array.

from numpy import arange

from dag_modelling.core.graph import Graph
from dag_modelling.plot.graphviz import savegraph
from dag_modelling.lib.common import Array
from dag_modelling.lib.arithmetic import Sum, Product

# Define a source data
array = arange(3, dtype="d")

# Check predefined Array, Sum and Product
with Graph(debug=debug) as graph:
    # Define nodes
    (in1, in2, in3, in4) = (Array(name, array) for name in ("n1", "n2", "n3", "n4"))
    s = Sum("sum")
    m = Product("product")

    # Connect nodes
    (in1, in2, in3) >> s
    (in4, s) >> m
    graph.close()

    print("Result:", m.outputs["result"].data) # must print [0. 3. 12.]
    savegraph(graph, "dag_modelling_example_1a.png")

The printed result must be [0. 3. 12.], and the created image looks as

For more examples see example/example.py or tests.

Please, note, that examples are using pygraphviz package, which is optional and not requested by default.

Additional modules

Supplementary python modules:

• dgm-reactor-neutrino — nodes related to reactor neutrino oscillations.
• dgm-fit — fitter interface.
• Daya Bay model — implementation of the Daya Bay oscillation analysis, development version.