Class Network

Allow the integrator to automatically add timepoints to the interior of
a trajectory.

This is slower, but may capture the dynamics better.

Add timepoints to the interior of a trajectory, plus 5% past the last
timepoint requested.

This produces the prettiest plots.

Add a compartment to the Network.

All species must reside within a compartment.

Add an event to the Network.

id - id for this event
trigger - The event firest when trigger passes from False to True.
    Examples: To fire when time becomes greater than 5.0:
               trigger = 'gt(time, 5.0)'
              To fire when A becomes less than sin(B/C):
               trigger = 'lt(A, sin(B/C))'
event_assignments - A dictionary or KeyedList of assignments to make
              when the event executes.
    Example: To set A to 4.3 and D to B/C
              event_assignments = {'A': 4.3,
                                   'D': 'B/C'}
delay - Optionally, assignments may take effect some time after the
    event fires. delay may be a number or math expression
name - A more detailed name for the event, not restricted to the id
    format

Add a constraint to the Network.

id - id for this constraint
trigger - We treat constraints as events that correspond to an
    invalid solution whenever the trigger is True.
    Example: To have an invalid solution when species A is > 5.0:
               trigger = 'gt('A', 5.0)'
name - A more detailed name for the constraint, not restricted to the id
    format

Add a function definition to the Network.

id - id for the function definition
variables - The variables used in the math expression whose
            values should be subsituted.
math - The math expression the function definition represents
name - A more extended name for the definition

Example:
    To define f(x, y, z) = y**2 - cos(x/z)
    net.add_func_def('my_func', ('x', 'y', 'z'), 'y**2 - cos(x/z)')

Add an assignment rule to the Network.

A rate rules species that <var_id> = rhs.

Add a rate rule to the Network.

A rate rules species that d <var_id>/dt = rhs.

Add an algebraic rule to the Network.

An algebraic rule specifies that 0 = rhs.

Remove the component with the given id from the Network.

Components that can be removed are variables, reactions, events,
function definitions, assignment rules, rate rules, and constraints.

set_stochastic enables the stochastic simulation of the network
dynamics (instead of deterministic integration). This will discretize
the dynamic variables in the model (making them integers). This
simulation has only limited support for events*, and does not
implement algebraic rules** or rates rules**. We use a kinetic MC
algorithm (aka Gillespie algorithm). The complementary function
'set_deterministic' may be used to disable stochastic simulations of
network dynamics. Please note the results returned for exactly the
times asked are interpolations between the surrounding points, thus
concentrations may be floats instead of integers.

* Since there is no exact way to implement events in a stochastic
  simulation, only a very primative method is present. This algorithm
  currently only supports time triggered events (more complex triggers
  may be added in the future) and fires them as soon after that time
  is passed as possible. Please note that it is the users
  responsibility to ensure the events are firing in a sensible
  way. Non-sensible output will arise when the time steps are too
  large and events are not fired near their target trigger times. The
  fired times are logged in the logger at the debug level.

** Possible future implementation, although parsing rate rules have the
   possible issue of creating negative reaction rates (which have no
   physical meaning). Add reactions instead of rate rules for stochastic
   simulations.

Inputs:
(seed=None, fill_dt=None, rmsd=None)
seed -- RNG seed used in the simulation. If none, generated from the
        system time and os.urandom (if available).
fill_dt -- Fill in the trajectory at the requested time interval. This
           is the simplest way to fill in a trajectory.
rmsd -- Maximum root mean squared distance in the dynamic variable
        space before taking a data point (a better trajectory filler).

Outputs: None

set_periodic ensures that a period solution has satisfactorily
approached a limit cycle before returning the solution. Please note that
this has not been implemented for sensitivity calculations.

Inputs:
(period, xtol=0.001, maxfun=100, phase=None, minVel=None, level=2,
log=False, rel=False)
period -- initial guess of the period (required)
xtol -- tolerance required for convergence (all chemicals). If set too
        high, numerical (in)precision may cause no stable limit cycle.
maxfun -- maximum number of iterations (one trajectory found in each)
phase -- set to a ('name', value) tuple to set the t=0 solution to a
         particular state in systems which no forcing. Value may be
         'max','min', or a float concentration (careful with the later).
minVel -- used to detect fixed points:
          when the (max IC velocity)**2 < minVel the integration
          is halted, the stability set to True, and the period set to
          0.0 (indicating nonperiodic, fixed point soln).
level -- correlation level (>=1) to use to find the period. For example,
         if level=2, the difference between x(0)-x(1*tau) and
         x(0)-x(2*tau) is used.
log -- Set to True to use logarithms of state variables, constraining
       the solution to non-zero values
rel -- Set to True to use relative differences (x1-x0)/min(x0,x1) in
       the limit cycle period search.
       
Outputs: (stored in net.periodic dictionary)
tol -- tolerance of the solution (rmsd of ic1 to ic0 for each level)
period -- actual period of oscillation
stable -- whether a stable solution was found
feval -- number of iterations
stableIC -- stable initial condition

Additionally, the period is accessible during the calculation and
afterwards via the '_tau' variable (useful for assignments which
rely on the period).

Return the current variable values as a KeyedList

ids -- List o variable ids to return values for. If None, all variables
       are used.

Update the net's optimizable vars from a passed-in KeyedList,
 dictionary, or sequence.

Only those variables that intersect between the net and params are
changed if a KeyedList or dict is passed in.

Create the dynamically-generated functions for this Network.

Note that if a model involves many copies of the same network, with 
differences only in events or initial conditions, it will save time
to compile the base Network before copying it.

Take the derivative of a math expression wrt a given variable id.

Does the chain rule through assigned variables.

Add a rate rule to the Network.

A rate rules species that d <var_id>/dt = rhs.

Update the net's optimizable vars from a passed-in KeyedList,
 dictionary, or sequence.

Only those variables that intersect between the net and params are
changed if a KeyedList or dict is passed in.

Add a function definition to the Network.

id - id for the function definition
variables - The variables used in the math expression whose
            values should be subsituted.
math - The math expression the function definition represents
name - A more extended name for the definition

Example:
    To define f(x, y, z) = y**2 - cos(x/z)
    net.add_func_def('my_func', ('x', 'y', 'z'), 'y**2 - cos(x/z)')

Add an assignment rule to the Network.

A rate rules species that <var_id> = rhs.