Graph visualization

[himoto]

Hi @formersbach,

My plan is as follows. Discussions & comments are always more than welcome!

Expected:

from biomass import create_model
model = create_model(...)
model.to_graph(fname="...")
# A graph image (fname.pdf or png) will be saved to the model.path

Implementation:

1. graph.py

class  NetworkGraph(object):
    
    def __init__(self, path: str, biomass_model: ModuleType):
        self._path = path
        self._parameters = biomass_model.C.NAMES
        self._species = biomass_model.V.NAMES
        self.pval = biomass_model.param_values
        self.ival = biomass_model.initial_values
        self.problem = biomass_model.OptimizationProblem()
        self.viz = biomass_model.Visualization()
        self.rxn = biomass_model.ReactionNetwork()

    @property
    def path(self) -> str:
        return self._path

    @property
    def parameters(self) -> List[str]:
        return self._parameters

    @property
    def species(self) -> list:
        return self._species

    @property
    def observables(self) -> List[str]:
        duplicate = [
            name for name in set(self.problem.obs_names) if self.problem.obs_names.count(name) > 1
        ]
        if not duplicate:
            return self.problem.obs_names
        else:
            raise NameError(f"Duplicate observables: {', '.join(duplicate)}")
    ...
    def to_graph(fname: str):
        ...
        plt.savefig(os.path.join(self.path, fname)

2. exec_model.py

from .graph import  NetworkGraph
...

class ModelObject(NetworkGraph):
   
    def __init__(self):
        super().__init__()
    ...

TODO:

• Create biomass/graph.py
• Create tests/test_graphviz.py and add test code there
• Create a PR to graphviz branch

[formersbach]

Should the User specify whether the flux equations or ode's should be used or should that be detected automatically?
Additionally should flux or ode be used as the default?

[himoto]

Do you think we can detect it automatically?
Since we can access info. about reaction network in a model via self.rxn in the NetworkGraph class, I think we can do like below:

class  NetworkGraph(object):
    ...
    try:
        if len(self.rxn.flux()) > 0:
            # flux equations should be used.
    except AttributeError:
        # ode should be used.
    ...

In the example of circadian clock, because this model does not have flux method in the ReactionNetwork class, the ode.py file will be used. In the TGFb model on the other hand, it satisfies the condition in the try section above and reaction_netwrok.py will be used. Is it possible to implement this?

[himoto]

I am sorry I forgot that flux requires arguments: t (time), y (conc.), and x (params).

class  NetworkGraph(object):
    ...
    try:
        if len(self.rxn.flux(0, self.ival(), self.pval())) > 0:
            # flux equations should be used.
    except AttributeError:
        # ode should be used.
    ...

[formersbach]

Is flux calculation computationally expensive? If not, your way is probably the easiest.
Can the definition of equations not only go from flux -> ode but the other way around (ode -> flux) as well?

[himoto]

I believe it is computationally cheap as it only calculates the flux at a single time-point.

Can the definition of equations not only go from flux -> ode but the other way around (ode -> flux) as well?

It is always from flux -> ode direction, otherwise all the information should be described in ode.py.