Forums

Hello all,

Hopefully I'm not presuming too much, but (in my mind) a way to
handle sboTerms might go something like this:

There's two major tasks that use sboTerms: reading & writing SBML files
(ok duh). Each task involves the conversion to or from the SBML to some
internal representation.
Here, we will assume that we have an internal database of SBO terms for
rate laws, species, and kinetic parameters which we may match against.

The database of SBO terms might look like (I'll omit the URL for brevity):

#SBO:000001 1st order mass action reaction
#SBO:000002 2nd order mass action reaction -- bimolecular
#SBO:000003 2nd order mass action reaction -- monomolecular
#SBO:000004 Michaelis Menten reaction
#SBO:000005 Michaelis Menten + Inhibition reaction
#SBO:100001 1st Reactant species
#SBO:100002 2nd Reactant Species
#SBO:100003 1st Product species
#SBO:100004 2nd Product species
#SBO:100005 Enzyme Catalyst #1
#SBO:100006 Inhibitor #1
#SBO:200001 Mass action kinetic constant (x units)
#SBO:200002 Kcat (x units)
#SBO:200003 Km (x units)

'x units' are the units of the parameters.

Using a GUI and a drop down menu, one can add the reaction 'A --> B'
with 1st order mass action kinetics, where 'A' is the '1st Reactant
Species' and 'B' is the '1st Product Species'.
The GUI then writes the following SBML (excuse any errors, but you'll
get the gist):

<listOfReactions>
<reaction id = "Example Reaction"
<kineticLaw>
<sboTerm = #SBO:000001/>
</kineticLaw>
<listOfReactants>
<speciesReference species = "A" stoichiometry = "1" sboTerm
= #SBO:100001 />
<listOfReactants/>
<listOfProducts>
<speciesReference species = "B" stoichiometry = "1" sboTerm
= #SBO:100003/>
<listOfProducts/>
<listOfParameters>
<parameter id = "k1" sboTerm = #SBO:200001/>
</listOfParameters>
</reaction>
</listOfReactions>

This labels 'A' as the 1st reactant species, 'B' as the 1st product
species, identifies the reaction rate law as '1st order mass action',
and signifies the kinetic constant as the mass action kinetic constant
(with a particular set of units).

When reading the above SBML and converting it into an internal
representation in the program, one might do:
-look up the sboTerm for the kineticLaw and find the matching rate
law in the internal list (hard coded for compiled languages)
-match the species in the rate law by creating an index by
identifying where species in the listOfReactants, listOfModifiers, and
listOfProducts belong in the rate law
-convert the units of the parameters to whatever necessary ones
(also using the SBO term of the kinetic parameter to know what the
original units are) and create an index by identifying where each
kinetic parameter belongs in the rate law.

So the rate law for this reaction is r = k * X1. Convert 'k1' to 1/sec,
identify it as the 1st kinetic parameter in the rate law, and identify
'A' as X1. Create indexes to very quickly substitute values of 'A' into
the variable 'X1'.

Ok, now for a Michaelis Menten reaction:

Now, setting the reaction to 'A --> B' but now with the Michaelis Menten
rate law (with an enzyme 'Catalyst' as catalyst), would look like:
<listOfReactions>
<reaction id = "Example Reaction Michaelis Menten"
<kineticLaw>
<sboTerm = #SBO:000004/>
</kineticLaw>
<listOfReactants>
<speciesReference species = "A" stoichiometry = "1" sboTerm
= #SBO:00001 />
<listOfReactants/>
<listOfModifiers>
<speciesReference species = "Catalyst" stoichiometry = "1"
sboTerm = #SBO:10005 />
<listOfModifiers>
<listOfProducts>
<speciesReference species = "B" stoichiometry = "1" sboTerm
= #SBO:00003/>
<listOfProducts/>
<listOfParameters>
<parameter id = "kcat" sboTerm = #SBO:200002 />
<parameter id = "Km" sboTerm = #SBO:200003 />
</listOfParameters>
</reaction>
</listOfReactions>

The rate law for Michaelis Menten is r = kcat*E*S / (Km + S). So,
reading the above SBML and converting it to the internal representation,
might go like:
--Identify reaction as using Michaelis Menten rate law.
--Convert kcat, Km to appropriate units (using sboTerm to denote the
original units).
--Identify the substrate, product, and enzyme species using sboTerms and
create indexes to quickly substitute values.

So 'A' --> 'S' , 'B' --> 'P' , 'Catalyst' --> 'E'.
Note that 'B' is only in the stoichiometry and not in the rate law while
'Catalyst' is only in the rate law and not in the stoichiometry. 'A' is
in both.

Using the sboTerms, it is straightforward to write out the
standard/simplest MathML expression for the kineticLaw. However, _it is
not straightforward to do that in reverse without the sboTerms_.
An example:

Consider the algebraic expression r = E*S / (Km / kcat + S / kcat). Is
this the Michaelis Menten rate law? It is (multiply the top and bottom
by kcat). It is algebraically equivalent. In fact, one can write out an
_infinite_ number of algebraically identical expressions for the
Michaelis Menten rate law. There is no easy way to 'match' an arbitrary
algebraic expression to a hard coded list. That is one major reason why
sboTerms are so needed.

I hope this gives some examples for an informed discussion of the usage
of sboTerms, their necessary, advantages, disadvantages, alternatives, etc.

-Howard Salis

Michael Hucka wrote:

> bshapiro> Its not just the reaction that needs to have the
> bshapiro> correct SBO term: don't all of the appropriate
> bshapiro> parameter values also need to have corresponding
> bshapiro> (correct) SBO Terms (or some equivalent
> bshapiro> information) for the kinetic law to be fully
> bshapiro> specified independent of the math fields?
>
>But, won't a parameter declared as (e.g.) "rate constant for
>first-order mass action" remain the same no matter if the
>kinetic law itself is changed? Or (e.g.) "Michaelis
>constant"?
>
> bshapiro> So we can't just ignore the kineticLaw if
> bshapiro> there is an SBO term, we have to read the
> bshapiro> parameter values and figure out where the go in
> bshapiro> the reaction specified by the SBO term.
>
>I thought of this when I was writing my other message, but
>decided it seemed like the meanings of the quantities and
>other elements of a model would stay the same despite that a
>change in a formula may change how they are *used*. This
>assumption may be incorrect. I'd like to see a case example
>if so.
>
>MH
>
>