Compartments in BNGL

From BioNetWiki

Jump to: navigation, search

Contents

Overview of Compartments in BNGL

A paper based on Compartmental BNGL appeared in the 2009 Proceedings of the Winter Simulation Conference. Links to the paper, an example model, and the latest cBNGL release are found here.

A tutorial of compartmental BNGL.

Development Notes

  • Autoscaling of kinetic rate parameters for compartment volume is controversial. We expect that the final implementation will allow for more general formulas for assigning rate parameters across compartments for universal rules. Such formulas may include volumes, surface areas, diffusion rates, etc. Comments and opinions are appreciated here.
  • The current implementation forbids the use of species localization context (i.e. @C: Species) when the molecular composition of the species is changed by a rule. We hope to alleviate these restrictions soon. UPDATE: this restriction no longer exists in the latest release of cBNGL (2.1.5+).
  • We plan to implement compartment typing in the near future. Compartment typing will allow for more general transport rules. The current implementation requires enumeration of transport for all named compartments.
  • Many models require the specification of a large number of similar (or identical) compartmented objects, such as cells. We plan to implement a data structure which allows a modeler to construct a compartmented object and then instantiate multiple copies of the object.

Compartment BNGL Documentation

The following is preliminary documenation for the latest implementation of compartments in BioNetGen. The details may differ from Jim's original specification (see Supplement). In particular, rules which create molecules or species must explicitly declare a compartment for the new objects. This is a work in progress, please offer your advice and suggestions.

Units

The following unit conventions are assumed:

  • Extensive units (counts or moles, not concentration).

Extensive units are necessary for proper accounting of transport reactions. Transport of Intensive units requires volume correction factors that are not currently implemented and are ill-defined in stochastic simulations.

  • Bimolecular rate constants are given per unit volume.

Bimolecular reaction rates depend on the volume of reaction compartment when populations are given as extensive variables. Compartment BNG automatically scales bimolecular reaction rates by the inverse of the volume of the reaction compartment. This auto-scaling feature permits the use of "Universal Reaction Rules" that generate a set of reaction instances, which are appropriately scaled to the volume of each compartment.


Declaring Compartments

Compartments are declared in the "compartments block". The format of the compartment block is as follow:

begin compartments
   compartment1_name  dimension  volume
   compartment2_name  dimension  volume   [outside_compartment]
     ...
   compartmentN_name  dimension  volume   [outside_compartment]
end compartments
  • Compartment_name: Unique alphanumeric identifier (of one or more characters). Perl Regex: [\w+]
  • Dimension: Either 2 or 3. Dimension 2 specifies a surface (e.g. plasma membrane). Dimension 3 specifies a volume (e.g. cytoplasm).
  • Volume: Either the volume of compartment (if dim=3) or an "effective volume of a surface" = surface_area * effective_width (if dim=2). Effective width may take into account the average tether-length of molecules bound to the membrane and the slower diffusion in a membrane versus the cytoplasm.
  • Outside_compartment: (optional) The name of the compartment immediately "outside" of the compartment (e.g. if this compartment is cytoplasm, the plasma membrane is immediately outside of the cytoplasm). The outside compartment must be defined before it is referenced (consequently the first compartment has no "outside").


Compartment Topology Rules

(generally analogous to SBML compartment topology)

  1. The outside of a surface must be volume (or undefined).
  2. The outside of a volume must be a surface (or undefined).
  3. A compartment may only have one outside.
  4. A volume may be outside of multiple surfaces.
  5. A surface may be outside of only one volume.

Example topology:

              ECF
             /   \
          PM1     PM2  
         /           \
      CP1             CP2
     /   \           /   \
  NM1     ERM1    NM2     ERM2     
   |       |       |       |
 Nuc1     ER1     Nuc2    ER2 

The compartment at top of the tree, ECF, is outermost. ECF is immediately outside surfaces PM1 and PM2. PM1 is immediately outside volume CP1, etc. Here's the declaration of this topology in the compartments block:

begin compartments
  ECF   3    vol_ECF                        # extra cellular fluid space
 
  PM1   2    sa_PM*eff_width    ECF         # plasma membrane of cell 1
  CP1   3    vol_CP             PM1         # cytoplasm of cell 1
  NM1   2    sa_NM*eff_width    CP1         # nuclear membrane of cell 1
  Nuc1  3    vol_Nuc            NM1         # nuclear space of cell 1
  ERM1  2    sa_ERM*eff_width   CP1         # ER membrane of cell 1
  ER1   3    vol_ER             ERM1        # ER lumen of cell 1
 
  PM2   2    sa_PM*eff_width    ECF         # plasma membrane of cell 2
  CP2   3    vol_CP             PM2         # cytoplasm of cell 2
  NM2   2    sa_NM*eff_width    CP2         # nuclear membrane of cell 2
  Nuc2  3    vol_Nuc            NM2         # nuclear space of cell 2
  ERM2  2    sa_ERM*eff_width   CP2         # ER membrane of cell 2
  ER2   3    vol_ER             ERM2        # ER lumen of cell 2
end compartments

Notes:

  1. The topology of the biological cell may differ from the BNG topology specification. For example, the ER membrane is topologically part of the nuclear membrane. But for most modeling purposes, the difference is not significant.
  2. Currently a multi-cell model requires explicit compartment declaration for each component of each cell. Future BNG versions may remove this limitation.
  3. Compartment parameters are defined in the parameter block, like all BNG parameters.


Compartments and the Molecule Types Block

Use of Compartments requires no changes to molecule types block.


Compartments and the Seed Species Block

If the compartment block is defined, each molecule initialized in the seed species block should have an assigned compartment.

  • Technical Note: It is not strictly required to assign molecules to a compartment. If a molecule is seeded without a compartment, then it is assigned to the default compartment "None". None is not topologically related to any named compartment. Therefore, molecules without compartment cannot interact with molecules that have been assigned to a named compartment. If one molecule in a species is assigned to a named compartment, then all molecules in that species must be assigned to a named compartment. It is poor form to seed species without a named compartment assignment.

There are two ways to assign a compartment to a molecule:

Molecule Compartment Notation (Postfix)

A molecule is explicitly assigned to a compartment using 'Molecule Compartment notation'. A single molecule is assigned to a compartment by adding "@CompartmentName" after the molecule specification.

Mol(a,b)@C

where Mol(a,b) is a molecule defined in the molecule types block and C is a compartment defined in the compartments block. Molecules in the same species may have different compartments, with some restrictions.

M(a)@CP.N(b)@PM


Species Compartment Prefix Notation (shortcut for molecule assignment)

A compartment can be assigned to every molecule in a species by using the species compartment notation:

@C:x.y.z  ==  x@C.y@C.z@C

This is simply a shortcut for saving time and reducing typographical errors. We can override the default "species" compartment by explicitly stating a molecule compartment.

@C:x.y.z@D  == x@C.y@C.z@D

Restrictions on Species with molecules in multiple compartments

A species may contain molecules in different compartments, with some restrictions to prevent the construction of physically unrealistic species and/or species which BioNetGen is not currently designed to handle. The restrictions are:

  • A bond may only form between molecules in the same or adjacent compartments. [note: this is not properly enforced in the seed species block, but is enforced during rule application. --justin]
  • If all molecules in a species are not in the same compartment, then at least one molecule must be contained in a surface compartment and the remaining molecules must be contained by that surface and its adjacent volume compartment(s).

A species which follows these rules is said to be a "localized species". More on this below.

Concept: Species Localization

In the current implementation, only Molecules can be assigned compartments (although it appears sometimes that we do assign species to compartments, really that is shorthand notation). But there is a concept of "species localization" which is important for determining if and how species interact under reaction rules.

  • Definition: Implicit Species Localization
let sLOC: Species -> Compartments U {invalid} U {none}
sLOC(x) = V,        if every molecule in species x has compartment V, where dimV=3
          S,        if at least one molecule in species x has comparment S, where dimS=2
                       and all other molecules are in compartments adjacent to S.
          none,     if all molecules in x have no compartment.
          invalid,  otherwise.
  • Definition: Explicit Species Localization

A species has explicit localization if the compartment prefix notation is used to assign the species to a compartment.

  • Definition: Localized Species

A species X is said to be localized if sLOC(X) != invalid and the explicit species localization (if any) is sLOC(X).

Reaction Rules and Compartments

A reaction rule in Compartment BNGL has the same basic syntax as vanilla BNGL. The key difference is the possible specification of species or molecule compartments in the reactant and product patterns. When compartments are omitted, a rule is universal: acting on all sets of matching reactants which are in the same compartment or adjacent compartments. If compartments are specified, the rule is restricted to reactants which match both the molecular and compartment pattern.

Compartment BNGL introduces two new rule operations: Molecule Transport and Species Transport. These new rules allow the modeler to describe cellular transport phenomenon such as nuclear traffic, receptor endocytosis, ion transport, etc.

Universal Rules

By default, a reaction rule is universal. A universal rule can be identified by observing that species or molecule compartments are not explicitly named in the reactant or product patterns. Universal rules are written exactly like rules in standard BNGL. A universal rule is applicable to any set of matching reactants that form an "interacting species set" (definition is below). Kinetic rates for universal rules are automatically adjusted to account for the volume of the reaction compartment. Reaction rate volume adjustments are covered later.


  • Definition: Interacting Species Set

A set of species is said to be "interacting" if each species is localized and one of the following is true:

  1. all species are localized in the same compartment (the universal "none" compartment counts here).
  2. all species are localized at a surface, S, and only one of its adjacent volumes, V.


  • A universal rule may delete reactant species or molecules, but may not create a new species or molecule. The compartment assignment of new species and molecules is not well defined. A future implementation may allow universal rules that create new objects whose compartment is assigned according to a defined convention.

Scope Restriction

Rule application may be restricted to species which match both a species pattern (vanilla BNGL) and a compartment pattern. This is accomplished by specifying species and/or molecule compartments in the reactant pattern and corresponding product pattern. Compartment specification in rules follows the same syntax as the seed species block.

# phosphorylate tyr if matching species is localized to membrane.
@PM:X(tyr~Y)  <->  @PM:X(tyr~pY)

# phosphorylate tyr if molecule X is assigned to compartment PM
X(tyr~Y)@PM   <->  X(tyr~pY)@PM


  • Note: The current implementation does not allow scope restriction with species compartment notation if the species undergoes a change in molecular composition or structure during rule application.
@CP:X(y) + @CP:Y(x)  <->  @CP:X(y!1).Y(x!1)
# Invalid syntax!  Species compartment notation not allowed if species undergo
# change in molecular composition or structure


Prior to network generation, a rule with scope restriction is validated to ensure that:

  1. Each pattern is "potentially localized".
  2. The set of reactants are "potentially interacting".

BNG will return an error at parse time if a rule fails on either point.


  • Definition: Implicit Pattern Location
let pLOC: Patterns -> Compartments U {indeterminant} U {invalid}
pLOC(x) = S,              if at least one molecule in pattern x has comparment S, where dimS=2.,
                            and all other molecules in pattern have undeclared compartment
                            or are in compartments adjacent to S.
          invalid,        if pattern x names molecules in two different surfaces, or in one surface and
                            a non-adjacent volume, or in two volumes that are not related by a surface.
          indeterminant,  otherwise.


  • Definition: Explicit Pattern Location

A pattern or species has explicit localization if species compartment prefix notation specifies a compartment: e.g. @V:pattern. An explicit pattern localization is compatible with an implicit location if they are equal or if the implicit pattern is indeterminant.


  • Definition: Potentially Localized Pattern

A pattern is said to be potentially localized if pLOC(x) != invalid, and explicit pattern localization (if any) is compatible with implicit localization. If a pattern is potentially localized, then its potential location is the explicit location or, if undefined, pLOC(x).

A pattern that is not potentially localized contains some irresolvable conflict of molecule and species compartment assignments that prevents any localized species from matching the pattern.


  • Definition: Potentially interacting Reactant Patterns

A set of reactant patterns are potentially interacting if all of the following are true:

  1. All reactant patterns are potentially localized.
  2. The set of determined potential locations (i.e. not indeterminant) is contained in a single compartment, or in a surface and only one of its adjacent volumes.

[Note: pattern compatibility could be extended to check for certain incompatibilities in patterns which are indeterminant. e.g. molecules in volumes which are not related by an adjacent surface.]

Bond Formation in compartment models

During network generation, BNG requires that bond formations only occur between molecules in the same or adjacent compartments.

  • Defintion: Interacting Components

A pair of components are said to be "interacting" if the molecules containing the components are in the same or adjacent compartments.

  • Definition: Valid Bonds

Bonds (edges) may only form between pairs of interacting components. Bonds which are not valid are "non-valid". Non-valid bonds are detected during network generation at the product construction stage. Products with non-valid bonds are rejected and a warning is issued to STDOUT.

Et cetera

  • Species/Molecule Creation

A rule which creates a new molecule or species must specify the compartment of each new molecule. The current implementation does not allow the Species Prefix notation as shorthand for assigning compartments to new molecules. Future versions may change this behavior.

   # Little Model: mRNA translated in CP.  Protein co-translocation to ER.

   # Correct rule: Protein assigned to ER
   mRNA@CP  ->  mRNA@CP  +  Protein@ER    k_translate

   # Incorrect: Protein assigned to "none" compartment.
   mRNA@CP  ->  mRNA@CP  +  @ER:Protein   k_translate


  • Currently it's impossible to restrict by explicit species localization if the species also undergoes a change in molecule composition. (this restriction does not apply to molecule compartment notation) e.g:
@PM: X(y) + @CP: Y(x)  ->  @PM: X(y!1).Y(x!1)     # not allowed.
X(y)@PM + Y(x)@CP      ->  X(y!1)@PM.Y(x!1)@CP    # ok, but not quite the same thing.

The problem here is that the reverse rule (if allowed) would be poorly defined and not fully revesible, since its impossible to determine before network generation whether X.Y will separate into species with the correct localization.


  • Molecule compartments behave almost exactly like components with a special syntax. The only difference is some restrictions on which compartment state transitions are allowed and automatic reaction rate adjustments for compartment volume.
X(tyr~Y,comp~PM) <-> X(tyr~pY,comp~PM)  behaves pretty much like below:
X(tyr~Y)@PM      <->  X(tyr~pY)@PM


  • Order of Operations
    • Transport operations are parsed last during the reaction rule parsing phase. BioNetGen will detect molecule deletions/additions, edge addtions/deletions, and component state changes before transport.
    • Transport operations are applied first during network generation.

Transport Rules

Transport rules move molecules or species from one compartment to another.

Molecule Transport

Molecule transport changes the compartment of a molecule. The molecule may be moved from a volume to an adjacent surface, or across a surface. Surface to surface molecular transport is not currently permitted. If molecule transport creates a product species with a non-valid bond (i.e. bonded molecules are not in same or adjacent compartments), then products are rejected and a warning is issued to STDOUT. A future "strict" mode is planned, which will force an abort when a non-valid bond is created.

A()@CP  <->  A()@PM           # insert A in the membrane
B().A()@CP  <->  B().A()@PM   # same as above, but within context of A.B complex
  • Scope restriction and Transport: The scope of a molecule transport may be restricted by requiring an explicit pattern location as long as the reactant and respective product pattern are both potentially localized.
@PM: X@CP  <->  @PM: X@EC      # will match X@CP in a species localized to PM.
                               # ok since its permissible for a species at PM to contain
                               # a molecule in the adjacent CP  or  EC.
@EC: X@CP  <->  @EC: X@EC      # NOT okay because it's impossible that X@CP can be in
                               # a species localized to EC.
Keyword: MoveConnected

A special type of molecule transport is required for transporting generic cargo. For example, in nuclear transport Importins bind a variety of cargo molecules and escort that cargo through the nuclear pore. This process could be modeled in cBNG using a molecule transport for each specific cargo molecule. This approach is tedious and prone to typographical error. To facillitate such models, the "MoveConnected" keyword is introduced to modify the behavior of a molecular transport. When a molecule is transported with the MoveConnected keyword, all molecules in the "compartment connected component" of the molecule are co-transported.

  • Definition: Compartment Connected Component

The compartment connected component of a molecule M@C in species X is the set of molecules in X which are connected to M by a path contained in C.

Importin()@CP  <->  Importin()@NU    kp, km  MoveConnected  # Transport Importin and any molecules in its compartment
                                                            # connected component.


Species Transport

Species transport changes the compartment of a species. Currently this type of transport is limited to reactant patterns which do not undergo any changes in molecule composition under the rule (no edge deletions or additions, and no molecule additions or deletions).

Species Transport is further restricted to two cases:

  • Volume to Volume transport. Move all molecules in a matching species to a new volume compartment. All molecules in a species localized to a volume must have the same compartment, so this rule is all well defined.
@V1:X  <->  @V2:X              # move species that matches pattern X from V1 to V2.
  • Surface to Surface transport. This transport is restricted to surface pairs that share an adjacent volume. This type of transport is more complex because species localized to a surface may contain molecules in the adjacent volumes. In the current implementation, a species transport moves all the molecules in species to the new location in a way that preserves inside-outside relationships of the constituent molecules. Molecules in the volume that is shared by the surfaces will remain in that volume after the species transport. This is like an endocytosis operation on a membrane receptor complex.
@S1:X <-> @S2:X

Molecules at S1 are transported to S2. Molecules in the shared volume stay in the shared volume. Molecules in the volume adjacent to S1 that is not shared with S2 are moved to the volume adjacent to S2 that is not shared with S1. All bonds within the species are preserved.

@PM:X  <->  @EnM:X  

specific instance:

A(r!1)@CP.R(a!1,b!2)@PM.B(r!2)@ECF <-> A(r!1)@CP.R(a!1,b!2)@EnM.B(r!2)@En

      ECF   PM     CP     ERM    ER
            |              |
            |              |
          y-x-z    <->   z-x-y
            |              |
            |              |


  • Be aware that species compartment prefix notation in a reaction rule can serve two purposes:
    1. Restrict pattern matches to species with specific localizations.
    2. Define a Species Transport operation.
# (1) phosphorylation resicted to species localized to compartment S.
@S: R(tyr~Y)  ->  @S:  R(tyr~pY)      k_phos

# (2) transport ion from CP to EC through ion channel.
@PM: ion_channel() + @CP: ion()  ->  @PM: ion_channel() + @EC: ion()   k_trans

Reaction Compartment and Volume Adjustments to kinetic parameters

Universal reaction rules describe a set of possible reactions which may occur in different compartments. Since bimolecular reaction rates depend on the compartment volume (when using Extensive species units), it is important to account for the reaction compartment volume during the network generation phase. Compartment BNG automatically determines the reaction compartment and adjusts reaction rates accordingly. The following table ennumerates the possible cases for a bi-molecular reaction. Volume_Comp describes a Dim=3 compartment while Surface_Comp describes a Dim=2 compartment. The reaction rate adjustment is the inverse of the volume of the reaction compartment.


Bi-molecular Reaction Compartment table:

Reactant1_Compartment  Reactant2_Compartment   Reaction_Compartment   Reaction_Rate_Adjustment
----------------------------------------------------------------------------------------------
   Volume_Comp            Volume_Comp             Volume                 1/V
   Surface_Comp           Volume_Comp             Volume                 1/V
   Surface_Comp           Surface_Comp            Surface                1/S


  • Intensive species units (concentrations) are not currently supported. Transport reactions under intensive units require volume scaling factors which are not currently implemented.
  • Reaction rate auto-adjustments may be used to approximate the effect of tethering a species to the membrane. When two interacting molecules are both tethered to a surface, the reaction rate will scale by the ratio of the effective surface volume to the original volume. If this effect is not desired, the rules should be written to restrict the reaction scope to the appropriate conditions.
  # B is a membrane protein, A is cytosolic but can be recruited to the membrane
  # auto-adjustment for tethering
  A(b) + B(a)  <->  A(b!1).B(a!1)    kp, km

  # manually handle membrane tethering (limit reaction scope)
  A(b)@CP + B(a)  <->  A(b!1)@CP.B(a!1)    kp1,km1   # case: cytosolic
  A(b)@PM + B(a)  <->  A(b!1)@PM.B(a!1)    kp2,km2   # case: tethered

  # this is tempting, but NOT VALID SYNTAX
  @CP:A(b) + @PM:B(a)  <->  @PM:A(b!1).B(a!1)
  @PM:A(b) + @PM:B(a)  <->  @PM:A(b!1).B(a!1)

The use of molecule compartments in the above example is limiting, since might have a cytosolic compartment while being tethered to the membrane through another molecule. The "tempting" syntax seems to lift that limitation, however it has problems of a different nature. In particular, patterns which match the RHS may not split into species with the proper localization. Future versions may support this syntax after a convention is established.

  • There is no volume-dependent reaction rate scaling for unimolecular reactions. This is almost always the correct behavior. One notable exception is passive unimolecular inter-compartment diffusion (i.e. diffusion which is not dependent on an explicit model of pores, channels, or transporters). As a first approximation, the rate of unimolecular inter-compartment diffusion depends on the concentration of the diffusing molecule and the area of the permeable surface that connects the compartments. Compartment BNG does not currently handle this situation. This can be handled manually by defining a psuedo-molecule whose population is a surrugate for the permeable surface area:
  # M is a molecule that diffuses between compartments A and B
  # S_AB is a pseudo-molecule representing the surface area shared by A and B
  M()@A + S_AB()  <->  M()@B + S_AB()   k_diff, k_diff

Observe that k_diff will be divided by the volume of A (or B) and multiplied by the population of S_AB, which represents the surface area.

Compartment BNGL Example Models

Nuclear Transport

# Model of Nuclear Transport
# cBNGL code by Justin, 30 March 2009
#
# based on description of nuclear transport at
# http://en.wikipedia.org/wiki/Nuclear_transport

begin model
begin parameters
  # arbitrary units
  kp1    0.1       # RanGTP binding (favored)
  km1    0.1       #   unbinding

  kp2    10.       # RanGDP unbinding (favored)
  km2    0.01      #   binding
  
  kp3    0.1       # Importin-Ran pickup (favored)
  km3    0.1       #   dropoff
  
  kp4    10.       # Importin+Ran dropoff (favored)
  km4    0.01      #   pickup
 
  kp5    0.1       # Exportin+Ran pickup (favored)
  km5    0.1       #   dropoff

  kp6    10.       # Exportin-ran dropoff (favored)
  km6    0.01      #   pickup

  kp7    0.01      # Portins enter nuclear pore (bimolecular)
  km7    1.0       #    leave pore (unimolecular

  k8     1.0       # Portins diffuses across pore

  kp9    0.01      # unbound Ran enter nuclear pore (bimolecular)
  km9    1.0       #    leave pore (unimolecular) 

  k10    1.0       # unbound Ran diffuses across pore
  
  k11    0.1       # RanGTP hydrolyzed in cytoplasm (bimolecular, fast)
  
  k12    0.1       # RanGDP reloaded with GTP in nucleus (bimolecular, fast)

  vol_EC  10.      # effective compartment volumes
  vol_PM  0.4 
  vol_CP  4.0
  vol_NM  0.1   
  vol_NU  1.0
end parameters


begin compartments
  EC  3  vol_EC 
  PM  2  vol_PM  EC
  CP  3  vol_CP  PM
  NM  2  vol_NM  CP
  NU  3  vol_NU  NM
end compartments


begin molecule types
  RanGEF()
  RanGAP()

  Ran(g~tp~dp,fg,port)   # g = gtp/gdp site, fg = hydrophobic residues, port = importin/exportin binding domain

  Importin(c,fg,ran)     # c = cargo site, ran = ran binding site
  Exportin(c,fg,ran)

  NucPore(fg)            

  Cargo1(im)             # im = importin binding site (import cargo)
  Cargo2(ex)             # ex = exportin bindning site (export cargo)
end molecule types


begin species
  # nuclear pore
  @NM:NucPore(fg)                     10
  
  # RanGEF is localized to Nucleus
  @NU:RanGEF()                        25
  
  # RanGAP is localized to Cytoplasm
  @CP:RanGAP()                       100
  
  # RanGDP in cytoplasm
  @CP:Ran(g~dp,fg,port)               40
  
  # RanGTP in nucleus
  @NU:Ran(g~tp,fg,port)               40
  
  # cargo molecules
  @CP:Cargo1(im)                     100
  @NU:Cargo2(ex)                     100
  
  # exportins/importins
  @CP:Importin(c,fg,ran)              20
  @NU:Exportin(c,fg,ran)              20
end species


begin reaction rules
  # RanGTP binds Importins and Exportins
  # note: ran shouldn't bind to Portins if its traversing the nucleopore
  Ran(fg,g~tp,port) + Importin(ran)  <->  Ran(fg,g~tp,port!1).Importin(ran!1)  kp1, km1
  Ran(fg,g~tp,port) + Exportin(ran)  <->  Ran(fg,g~tp,port!1).Exportin(ran!1)  kp1, km1

  # RanGDP unbinds Importins and Exportins
  Ran(fg,g~dp,port!1).Importin(ran!1)  <->  Ran(fg,g~dp,port) + Importin(ran)  kp2, km2
  Ran(fg,g~dp,port!1).Exportin(ran!1)  <->  Ran(fg,g~dp,port) + Exportin(ran)  kp2, km2


  # Importins tend to pickup cargo when not bound to Ran
  Importin(c,ran) + Cargo1(im)      <->  Importin(c!1,ran).Cargo1(im!1)        kp3, km3

  # Importins tend to dropoff cargo when bound to Ran
  Importin(c!1,ran!+).Cargo1(im!1)  <->  Importin(c,ran!+) + Cargo1(im)        kp4, km4

  # Exportins tend to pickup cargo when bound to Ran
  Exportin(c,ran!+) + Cargo2(ex)    <->  Exportin(c!1,ran!+).Cargo2(ex!1)      kp5, km5
  
  # Exportins tend to dropoff cargo when not bound to Ran
  Exportin(c!1,ran).Cargo2(ex!1)    <->  Exportin(c,ran) + Cargo2(ex)          kp6, km6


  # exportins/importins passively diffuse across nuclear pore
  Exportin(fg) + NucPore(fg)       <->  Exportin(fg!1).NucPore(fg!1)           kp7, km7
  Importin(fg) + NucPore(fg)       <->  Importin(fg!1).NucPore(fg!1)           kp7, km7
  Exportin(fg!1)@NU.NucPore(fg!1)  <->  Exportin(fg!1)@CP.NucPore(fg!1)        k8,  k8   MoveConnected
  Importin(fg!1)@NU.NucPore(fg!1)  <->  Importin(fg!1)@CP.NucPore(fg!1)        k8,  k8   MoveConnected
  
  # Ran passively diffuses across nuclear pore
  # note: this rule ONLY handles Ran which is not bound to portins
  Ran(fg,port) + NucPore(fg)       <->  Ran(fg!1,port).NucPore(fg!1)           kp9, km9
  Ran(fg!1,port)@NU.NucPore(fg!1)  <->  Ran(fg!1,port)@CP.NucPore(fg!1)        k10, k10  MoveConnected
  
  # RanGAP hydrolyzes Ran-GTP
  RanGAP() + Ran(g~tp)@CP           ->  RanGAP() + Ran(g~dp)@CP                k11
  
  # RanGEF exchanges GDP for GTP
  RanGEF() + Ran(g~dp)@NU           ->  RanGEF() + Ran(g~tp)@NU                k12
end reaction rules


begin observables
  Molecules  Cargo1_CP  Cargo1()@CP
  Molecules  Cargo1_NU  Cargo1()@NU

  Molecules  Cargo2_CP  Cargo2()@CP
  Molecules  Cargo2_NU  Cargo2()@NU

  Molecules  RanGEF_NU  RanGEF()@NU
  Molecules  RanGAP_CP  RanGAP()@CP
  
  Molecules  RanGDP_CP  Ran(g~dp)@CP
  Molecules  RanGTP_CP  Ran(g~tp)@CP

  Molecules  RanGDP_NU  Ran(g~dp)@NU
  Molecules  RanGTP_NU  Ran(g~tp)@NU

  Molecules  Importin_CP      @CP:Importin(ran)
  Molecules  Importin_NU      @NU:Importin(ran)
  Molecules  Importin_Ran_CP  @CP:Importin(ran!+)
  Molecules  Importin_Ran_NU  @NU:Importin(ran!+) 
  
  Molecules  Exportin_CP      @CP:Exportin(ran)
  Molecules  Exportin_NU      @NU:Exportin(ran)
  Molecules  Exportin_Ran_CP  @CP:Exportin(ran!+)
  Molecules  Exportin_Ran_NU  @NU:Exportin(ran!+)   
end observables
end model
Personal tools