chem

README

Docs: GoDoc

Package chem provides basic chemistry simulation algorithms, including:

• React -- chemical reaction where 2 components bind into a compound, characterized by forward and backward rate constants, Kf, Kb.

• Enz -- enzyme-catalyzed reaction based on the Michaelis-Menten kinetics that transforms S = substrate into P product via SE bound C complex.

• Buffer -- provides a soft buffering driving deltas relative to a target N which can be set by concentration and volume.

• Integrate -- performs basic forward Euler integration, using IntegrateDt rate constant.

• CoFmN and CoToN convert concentration to / from numbers of molecules given a volume (just multiplication and division, but useful for documenting the purpose).

In general, all of this code just computes deltas (discrete derivatives) for moving numbers of molecules around -- complex systems of reactions can be constructed and all the different deltas summed up, and applied in a step-wise fashion. At bottom, it is really very simple, involving massive simplifications that nevertheless seem sufficient to capture the relevant phenomena. In effect, the all-important rate constants absorb and compensate for all of those simplifications.

Kinetikit

This code is based on Kinetikit by Upinder S. Bhalla and implemented in the Genesis simulation tool. See:

• Bhalla, U. S., & Iyengar, R. (1999). Emergent Properties of Networks of Biological Signaling Pathways. Science. https://doi.org/10.1126/science.283.5400.381

See the axon urakubo model of LTP / LTD for a re-implementation of the Urakubo et al, 2008 model using this code.

• Urakubo, H., Honda, M., Froemke, R. C., & Kuroda, S. (2008). Requirement of an allosteric kinetics of NMDA receptors for spike timing-dependent plasticity. The Journal of Neuroscience, 28(13), 3310–3323. http://www.ncbi.nlm.nih.gov/pubmed/18367598

Here's another paper that Urakubo builds upon:

• Dupont, G., Houart, G., & De Koninck, P. (2003). Sensitivity of CaM kinase II to the frequency of Ca2+ oscillations: A simple model. Cell Calcium, 34(6), 485–497. https://doi.org/10.1016/S0143-4160(03)00152-0

Reactions

React models a basic chemical reaction:

      Kf
A + B --> AB
     <-- Kb

where Kf is the forward and Kb is the backward time constant. The source Kf and Kb constants are in terms of concentrations μM-1 and sec-1 but calculations take place using N's, and the forward direction has two factors while reverse only has one, so a corrective volume factor needs to be divided out to set the actual forward factor.

Enzymes

Enz models an enzyme-catalyzed reaction based on the Michaelis-Menten kinetics that transforms S = substrate into P product via SE bound C complex:

      K1        K3
S + E --> C(SE) ---> P + E
     <-- K2

S = substrate, E = enzyme, C = SE complex, P = product. The source K constants are in terms of concentrations μM-1 and sec-1 but calculations take place using N's, and the forward direction has two factors while reverse only has one, so a corrective volume factor needs to be divided out to set the actual forward factor.

Documentation

Index

• Variables
• func CoFmN(n, vol float64) float64
• func CoToN(co, vol float64) float64
• func Integrate(c *float64, d float64)
• type Buffer
  • func (bf *Buffer) SetTargVol(targ, vol float64)
  • func (bf *Buffer) Step(ca float64, da *float64)
• type Diffuse
  • func (rt *Diffuse) Set(kf, kb float64)
  • func (rt *Diffuse) SetSym(kfb float64)
  • func (rt *Diffuse) Step(ca, cb, va, vb float64, da, db *float64)
• type Enz
  • func (rt *Enz) Set(k1, k2, k3 float64)
  • func (rt *Enz) SetKm(km, k2, k3 float64)
  • func (rt *Enz) SetKmVol(km, vol, k2, k3 float64)
  • func (rt *Enz) Step(cs, ce, cc, cp float64, ds, de, dc, dp *float64)
  • func (rt *Enz) StepK(kf, cs, ce, cc, cp float64, ds, de, dc, dp *float64)
  • func (rt *Enz) Update()
• type React
  • func (rt *React) Set(f, b float64)
  • func (rt *React) SetVol(f, vol, b float64)
  • func (rt *React) Step(ca, cb, cab float64, da, db, dab *float64)
  • func (rt *React) StepK(kf, ca, cb, cab float64, da, db, dab *float64)
• type SimpleEnz
  • func (rt *SimpleEnz) Step(cs, ce float64, ds, dp *float64)

Variables

var IntegrationDt = 5.0e-5

IntegrationDt is the time step of integration for Urakubo et al, 2008: uses 5e-5, 2e-4 is barely stable, 5e-4 is not The AC1act dynamics in particular are not stable due to large ATP, AMP numbers

Functions

func CoFmN

func CoFmN(n, vol float64) float64

CoFmN returns concentration from N, for given volume: co / vol

func CoToN

func CoToN(co, vol float64) float64

CoToN returns N based on concentration, for given volume: co * vol

func Integrate

func Integrate(c *float64, d float64)

Integrate adds delta to current value with integration rate constant IntegrationDt new value cannot go below 0

Types

type Buffer

type Buffer struct {
	K    float64 `desc:"rate of buffering (akin to permeability / conductance of a channel)"`
	Targ float64 `desc:"buffer target concentration -- drives delta relative to this"`
}

Buffer provides a soft buffering driving deltas relative to a target N which can be set by concentration and volume.

func (*Buffer) SetTargVol

func (bf *Buffer) SetTargVol(targ, vol float64)

func (*Buffer) Step

func (bf *Buffer) Step(ca float64, da *float64)

Step computes da delta for current value ca relative to target value Targ

type Diffuse

type Diffuse struct {
	Kf float64 `desc:"A -> B forward diffusion rate constant, sec-1"`
	Kb float64 `desc:"B -> A backward diffusion rate constant, sec-1"`
}

Diffuse models diffusion between two compartments A and B as a function of concentration in each and potentially asymmetric rate constants -- A Kf -> B and B Kb -> A computes the difference and applies to each

func (*Diffuse) Set

func (rt *Diffuse) Set(kf, kb float64)

Set sets both diffusion rates

func (*Diffuse) SetSym

func (rt *Diffuse) SetSym(kfb float64)

SetSym sets symmetric diffusion rate (Kf == Kb)

func (*Diffuse) Step

func (rt *Diffuse) Step(ca, cb, va, vb float64, da, db *float64)

Step computes delta A and B values based on current A, B values inputs are numbers, converted to concentration, then back to numbers for the deltas.

type Enz

type Enz struct {
	K1 float64 `desc:"S+E forward rate constant, in μM-1 msec-1"`
	K2 float64 `desc:"SE backward rate constant, in μM-1 msec-1"`
	K3 float64 `desc:"SE -> P + E catalyzed rate constant, in μM-1 msec-1"`
	Km float64 `inactive:"+" desc:"Michaelis constant = (K2 + K3) / K1 -- goes into the rate"`
}

Enz models an enzyme-catalyzed reaction based on the Michaelis-Menten kinetics that transforms S = substrate into P product via SE bound C complex

K1         K3

S + E --> C(SE) ---> P + E

<-- K2

S = substrate, E = enzyme, C = SE complex, P = product The source K constants are in terms of concentrations μM-1 and sec-1 but calculations take place using N's, and the forward direction has two factors while reverse only has one, so a corrective volume factor needs to be divided out to set the actual forward factor.

func (*Enz) Set

func (rt *Enz) Set(k1, k2, k3 float64)

Set sets time constants in seconds directly

func (*Enz) SetKm

func (rt *Enz) SetKm(km, k2, k3 float64)

SetKm sets time constants in seconds using Km, K2, K3

func (*Enz) SetKmVol

func (rt *Enz) SetKmVol(km, vol, k2, k3 float64)

SetKmVol sets time constants in seconds using Km, K2, K3 dividing forward K1 by volume to compensate for 2 volume-based concentrations occurring in forward component (s * e), vs just 1 in back

func (*Enz) Step

func (rt *Enz) Step(cs, ce, cc, cp float64, ds, de, dc, dp *float64)

Step computes delta values based on current S, E, C, and P values

func (*Enz) StepK

func (rt *Enz) StepK(kf, cs, ce, cc, cp float64, ds, de, dc, dp *float64)

StepK computes delta values based on current S, E, C, and P values K version has additional rate multiplier for Kf = K1

func (*Enz) Update

func (rt *Enz) Update()

type React

type React struct {
	Kf float64 `desc:"forward rate constant for N / sec assuming 2 forward factors"`
	Kb float64 `desc:"backward rate constant for N / sec assuming 1 backward factor"`
}

React models a basic chemical reaction:

Kf

A + B --> AB

<-- Kb

where Kf is the forward and Kb is the backward time constant. The source Kf and Kb constants are in terms of concentrations μM-1 and sec-1 but calculations take place using N's, and the forward direction has two factors while reverse only has one, so a corrective volume factor needs to be divided out to set the actual forward factor.

func (*React) Set

func (rt *React) Set(f, b float64)

Set sets reaction forward / backward time constants in seconds

func (*React) SetVol

func (rt *React) SetVol(f, vol, b float64)

SetVol sets reaction forward / backward time constants in seconds, dividing forward Kf by volume to compensate for 2 volume-based concentrations occurring in forward component, vs just 1 in back

func (*React) Step

func (rt *React) Step(ca, cb, cab float64, da, db, dab *float64)

Step computes delta A, B, AB values based on current A, B, and AB values

func (*React) StepK

func (rt *React) StepK(kf, ca, cb, cab float64, da, db, dab *float64)

StepK computes delta A, B, AB values based on current A, B, and AB values K version has additional rate multiplier for Kf

type SimpleEnz

type SimpleEnz struct {
	Kf float64 `desc:"S->P forward rate constant, in μM-1 msec-1"`
}

SimpleEnz models a simple enzyme-catalyzed reaction that transforms S = substrate into P product via E which is not consumed assuming there is much more E than S and P -- E effectively acts as a rate constant multiplier

Kf*E

S ----> P

S = substrate, E = enzyme, P = product, Kf is the rate of the reaction

func (*SimpleEnz) Step

func (rt *SimpleEnz) Step(cs, ce float64, ds, dp *float64)

Step computes delta S and P values based on current S, E values