The simulation class should be generated from a bond graph.

As input it should:

• Require you to specify the initial conditions.
• Require you to specify parameter values (constant only)
• Require a time window

The class should then derive the system equations from the bond graph and pass them to numpy or scipy to integrate.

The output for now should be a tuple of arrays (t,x).

Develop test suite for RLC model.

Tests should:

• verify that a bond graph can be turned into a system of the form Ay +Bx + F(x, y, t; u) = 0

Add feature to bond graph model that allows users to swap components of the same type in.
For example; replacing a Ce with a Se

Specifically, make sure _construct_edge_subs is being called in the right way,
and make sure it's doing what it's supposed to.
and unit tests.

When building biochemical reactions, there are particular parameters (such as volume) that we'd like to be shared across the entire compartment.

Once this issue is closed, we should be able to connect a components parameter to a reference value stored at the enclosing model.

In order to be consistent with the literature; we need to change the base implementation of the 1 component such that is has two distinct sets of ports; 'power in' and 'power out' ports.

Save/load to own file format (JSONS?).

Probably should encode for:

• Software version
• Used libraries and library version.

The reaction_builder requires tests to verify that the chemostat and flowstat components are building correctly.

Tests should verify that adding chemostats and flowstats:

• Don't lose reactions.
• Anchor species correction.
• Pass on parameters to the network model correctly.

So, as the title says; get diodes working.

In order to cater to the traditional bond graphers, some components need to be aware of directionality.

We should have some kind of non-intrusive legacy mappping between connection order and ports.

In particular
connect(C, 1) should be isomorphic to connect(C, 1.input)
and connect(1, C) should be isomorphic to connect(1.output, C)

This task involves adding the Source-Sensor (SS) component to component library.

Associated tests should verify that:
SS has been added and new external port has been added to the model.

• Control/modulation network.
• Measurement (effort/flow to control variable) functionality.
• Proper logging functionality.
• User-made libraries.
• Tutorials:
  • Using control and modulation to implement an Op-Amp (ala Metamodelling - P. Gawthrop)
  • Making a new component: Suspended ball (ala pH - van Der Schaft et al).

• Save and Load Functionality.
• External power ports.
• Modular models.
• Posix-like model hierarchy.
• Tutorials on modular model building.
• Discussion on mathematics of Bond Graph composition.
• How-to guides:
  • Installation.
  • Building and simulating a simple Bond Graph.

It doesn't look like the GitHUb wiki will suffice as a project website. There are clearly better solutions.

Find one, and migrate what little docs there are across

In addition to BondGraph -> CellML export, we should investigate whether or not CellML could act as a ODE/DAE solver.

Specifically, see if we can break up _build_co-ordinates into pieces.
Write unit tests.

Link gitchangelog so that we can automatically build changelogs from the git log.

See Project:Model Composition

Unit tests are required for:

• extract_coefficients
• is_linear
• linearise
• smith_normal_form
• null_space_basis

To do:

• Add modulated components mRe, mTf
• Add 'activated bonds'
• Allow connection to control variables (new or existing)

Particularly;

• Symbolic linearisation of nonlinear components
• Bode plots for single port compound components

We must be able to save to file.
This should match the schema specified in #51

We expect that the internal model is more complex than it needs to be, so we should also flag unnecessary parts for refactoring

A Bond Graph is a hierarchically organised set of components, with network interconnections at each level of the hierarchy.

Hence, the internal location of each component should obey a posix tree-like structure.

For this task we should change how the CompoundBondGraph class represents the sub-components, and make sure the API is consistent.

This will also involve cleaning up the different ways of referencing a component-in-bondgraph issues.

Build file loading infrastructure:

We require:
[ ] A versioned file structure (implemented in .yaml)
[ ] A file reader that is aware of the model file version, and can pass the data across the the appropriate data model.
[ ] Mechanisms to build the model from file data.

Users should be able to construct their own basic models and store them in a local library.
This task involves implementing the loading of user defined libraries.

Must be able to handle malformed libraries.
Might be necessary to migrate library management away from .json files (job for later if so)

Since we're saving files in .yaml, we should probably have a nice schema defined for reference.

We should probably let people poke around with it before setting it in ...'clay'.

Defer to v0.4

Write test scripts for build relations.

Should test all currently implemented node types, as well as junk and antagonistic data

Here we implement the functionality that makes users able to use a bond graph with a port(or many) as a component inside yet another bond graph

@peter-cudmore commented on Tue Feb 20 2018

See chapter's 2 and 3 of DAE book.
Specifically we need to:

1. Re-work how co-ordinates are constructed; particularly with respect to sockets
2. Re-work how the relations are used to generate a differential algebraic system.
3. Re-work how the reduced equations are generated; using

Ap = A.col_join(J)
Q = Ap.inv()
P = sp.eye(m).row_join(-B*Q[:,m:n]).col_join(sp.zeros(n-m, m).row_join(sp.eye(n-m)))
Ax = A.col_join(sp.zeros(*J.shape))
Bx = B.col_join(J)

Ad = P*Ax*Q
Bd = P*Bx*Q
Gd = P*G

y = Ap*x

The bond graph algebra sub-package should generate a set of differential algebraic equations.
However, we should always be able to map the reduced co-ordinate and parameter spaces used in the DAE's back to the actual parameter and local co-ordinate space for the bond graph.

To make this happen, we should think about how how simulation data is to be used.

Sympy has deprecated matrix.dot in some situations.
We should fix these warnings.

@peter-cudmore commented on Tue Feb 20 2018

With the corrected implementation of the 1 junction, we should remove the 'Y' junction from the reaction builder addon and instead the 1 junction and transformers instead.

One would like to connect two composite models together, and have everything work.
Most of the infrastructure should already be there, with the exception being the Source Sensor component.

Tests should involve:

• building a passive 2nd order filter out of two coupled 1st order reactions.
• coupling two enzyme catalyzed reactions in a chain.

Julia and diffeq.py take ages to start.
Its rare that a user needs them immediately, so we should use a worker thread to load them in the background.