cell_cycle 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b279cc91b177efae9a32de303f23d582e1f061b5
+  data.tar.gz: 39b00bc0f002c0c7b676621ab58825271d92f30d
+SHA512:
+  metadata.gz: c5b2008d7d4144bd1ee6a8b35d8e4fb9310e89c3a36b377b2b26455ed675dd106c9fbd73ded3f389b22ff646a92a9f63e2275461bdfdd68d41bc048ac85b8299
+  data.tar.gz: d1b26d72b9f5c4ac1ced003eae61312ebacbec63330fb64babe858b91799c05458fe693460d3e1ad85507c08d6b76f946e3a1eb9b3619226881ae028d5f9990e

data/.gitignore

@@ -0,0 +1,20 @@
+*~
+.#*
+\#*#
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/ACKNOWLEDGMENT.txt

@@ -0,0 +1,6 @@
+This document serves to acknowledge the support of Bioinformatics Program,
+Taiwan International Graduate Program, Institute of Computer Science,
+Academia Sinica (128, Academia Road, Sec. 2. Namkang, Taipei, 115), and
+of Bioinformatics Institute, National Yang-Ming University, Taipei,
+Taiwan. Without their support, creation of this package would not be
+possible.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cell_cycle.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 boris
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# CellCycle
+
+Cell cycle model.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cell_cycle'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cell_cycle
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/cell_cycle/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/run_virginia

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+set_step 1; set_sampling 300; set_target_time 3600 * 24
+new_simulation
+run!
+recording.plot

data/cell_cycle.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cell_cycle/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cell_cycle"
+  spec.version       = CellCycle::VERSION
+  spec.authors       = ["boris"]
+  spec.email         = ["\"boris@iis.sinica.edu.tw\""]
+  spec.summary       = %q{A model of eukaryotic cell cycle.}
+  spec.description   = %q{Eukaryotic cell cycle modelled at different levels of precision. Has two levels at the moment: Simple and Virginia Tech.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/cell_cycle/alternative_syntax_for_transitions.rb

@@ -0,0 +1,351 @@
+# encoding: utf-8
+
+# Generic cell cycle published in Csikasznagy2006agm, alternative syntax of
+# the transitions.
+
+# == TRANSITIONS ================================================================
+
+# This creates a timed stoichiometric (TS) transition representing cell growth.
+# Cell growth changes Mass (domain), and its stoichiometry is { Mass: 1 }, that
+# is, Mass simply increases at the rate indicated by the transition's function.
+# The function (rate) is given by the formula m * CELL_GROWTH_RATE, where m is
+# the current mass of the cell, and CELL_GROWTH_RATE a constant given by the model
+# authors.
+# 
+Cell_growth = Transition domain: Mass,
+                         stoichiometry: { Mass: 1 },
+                         rate: -> m { m * CELL_GROWTH_RATE }
+
+# This creates an assignment (A) transition representing cytokinesis. It changes
+# 2 places (codomain): Mass, and Ck_license. Mass is the cell mass, Ck_license is
+# a special place that was added to the Petri net to prevent Cytokinesis transition
+# from accidentally firing twice in a row in the same cycle. Firing depends on,
+# in order, Mass, Ck_license, and ActCycB (domain). The function thus takes 3
+# arguments (mass, license, b). If ActCycB is under the threshold specified by
+# the model authors (CycB_DIVISION_THRESHOLD), and Ck_license is cocked
+# (equal to 1), then the mass is halved and the license is consumed (set to 0).
+# Otherwise, the [ mass, license ] pair is returned unchanged. The :pseudo_euler
+# simulation method fires the transition once after each simulation step.
+# 
+Cytokinesis = Transition codomain: [ Mass, Ck_license ],
+                         domain: [ Mass, Ck_license, ActCycB ],
+                         assignment: -> mass, license, b do
+                           if license == 1 and b < CycB_DIVISION_THRESHOLD then
+                             [ mass / 2, 0 ] # mass is halved, license is set to 0
+                           else
+                             [ mass, license ] # nothing happens
+                           end
+                         end
+
+# An assignment transition that controls the Ck_license cocking (codomain), and
+# whose firin depends on Ck_license and the level of ActCycB (domain). The
+# assignment function cocks the license (sets it to 1) if the level of ActCycB
+# is above CycB_DIVISION_THRESHOLD plus 10% margin. Otherwise, the license is
+# unchanged. Again, the :pseudo_euler simulation method fires the transition once
+# after each simulation step.
+# 
+License_cocking = Transition codomain: Ck_license,
+                             domain: [ Ck_license, ActCycB ],
+                             assignment: -> license, b do
+                               if b > CycB_DIVISION_THRESHOLD * 1.1 then
+                                 1
+                               else
+                                 license
+                               end
+                             end
+
+# === Module 1
+
+# Cdc20T synthesis and degradation functions defined as lambda expressions
+# according to the definitions in Csikasznagy2006agm.
+# 
+Cdc20T_synthesis = -> b { x = b ** N; ( Ks20p + Ks20pp * x ) / ( J20 ** N + x ) }
+Cdc20T_degradation = -> cdc20T { cdc20T * Kd20 }
+
+# A timed stoichiometric transition representing the change of anaphase-promoting
+# factor (Cdc20T). Its stoichiometry is thus { Cdc20T: 1 }. Its rate depends on
+# the level of activated cyclin B (ActCycB) and Cdc20T). The function is modified
+# to enable larger execution step with :pseudo_euler method.
+# 
+Cdc20T_change = Transition domain: [ ActCycB, Cdc20T ],
+                           stoichiometry: { Cdc20T: 1 },
+                           rate: -> b, t {
+                             step = world.simulation.step.to_f
+                             fine_step = step / 50.0
+                             orig = t
+                             # Fine-step the function.
+                             50.times do
+                               t += ( Cdc20T_synthesis.( b ) - Cdc20T_degradation.( t ) ) * fine_step
+                             end
+                             ( t - orig ) / step # get the positive change rate
+                           }
+
+# # Without the modification for higher speed, there are 2 transitions
+# # Cdc20T_synthesis and Cdc20T_degradation as follows:
+# # 
+# Cdc20T_synthesis = Transition domain: [ ActCycB, Cdc20T ],
+#                               stoichiometry: { Cdc20T: 1 },
+#                               rate: -> b {
+#                                 x = b ** N; ( Ks20p + Ks20pp * x ) / ( J20 ** N + x )
+#                               }
+# Cdc20T_degradation = Transition stoichiometry: { Cdc20T: -1 },
+#                                 rate: Kd20
+
+# Cdc20 activation, inactivation and degradation functions defined as lambdas as
+# per Csikasznagy2006agm.
+# 
+Cdc20_activation = -> t, a, apcp { x = t - a; Ka20 * apcp * x / ( Ja20 + x ) }
+Cdc20A_inactivation = -> a { a * Ki20 / ( Ji20 + a ) }
+Cdc20A_degradation = -> a { a * Kd20 }
+
+Cdc20A_change = TS Cdc20T, Cdc20A, APCP, Cdc20A: 1 do |t, a, apcp|
+  step = world.simulation.step.to_f
+  fine_step = step / 50.0
+  orig = a
+  50.times do
+    a = a +
+      ( Cdc20_activation.( t, a, apcp ) -
+        Cdc20A_inactivation.( a ) -
+        Cdc20A_degradation.( a )
+        ) * fine_step
+  end
+  ( a - orig ) / step # return the positive change rate
+end
+
+# REMARK: This section has to be band-aided for speed:
+# Cdc20_activation = TS Cdc20T, Cdc20A, APCP, Cdc20A: 1 do |t, a, apcp|
+#   x = t - a; Ka20 * apcp * x / ( Ja20 + x )
+# end
+# Cdc20A_inactivation = TS Cdc20A: -1 do |a| a * Ki20 / ( Ji20 + a ) end
+# Cdc20A_degradation = TS Cdc20A: -1, rate: Kd20
+
+# REMARK: Just like in CI, this section has to be band-aided.
+
+APC_activation = -> b, apcp { x = 1 - apcp; KaAPC * b * x / ( JaAPC + x ) }
+APC_inactivation = -> apcp { KiAPC * apcp / ( JiAPC + apcp ) }
+
+APC_change = TS ActCycB, APCP, APCP: 1 do |b, apcp|
+  step = world.simulation.step.to_f
+  fine_step = step / 50.0
+  orig = apcp
+  50.times do
+    apcp += ( APC_activation.( b, apcp ) - APC_inactivation.( apcp ) ) * fine_step
+  end
+  ( apcp - orig ) / step
+end
+
+# APC_activation = TS ActCycB, APCP, APCP: 1 do |b, apcp|
+#   x = 1 - apcp; KaAPC * b * x / ( JaAPC + x )
+# APC_inactivation = TS APCP: -1 do |apcp| KiAPC * apcp / ( JiAPC + apcp ) end
+
+# === Module 2
+
+# REMARK: Cdh1 activation and inactivation joined into 1 and band-aided in CI,
+# and same has to be done here.
+
+Cdh1_activation = -> cdc14, cdh1 {
+  x = 1 - cdh1; ( Kah1p + Kah1pp * cdc14 ) * x / ( Jah1 + x ) # orig. formula
+}
+
+Cdh1_inactivation = -> a, b, d, e, cdh1 {
+  ( Kih1p + Kih1pp * a + Kih1ppp * b + Kih1pppp * e + Kih1ppppp * d ) *
+    cdh1 / ( Jih1 + cdh1 )
+}
+
+Cdh1_change =
+  TS ActCycA, ActCycB, CycD, ActCycE, Cdc14, Cdh1, Cdh1: 1 do
+  |a, b, d, e, cdc14, cdh1|
+  step = world.simulation.step.to_f
+  fine_step = step / 500
+  orig = cdh1
+  500.times do # fine-stepped formula
+    cdh1 += ( Cdh1_activation.( cdc14, cdh1 ) -
+              Cdh1_inactivation.( a, b, d, e, cdh1 ) ) * fine_step
+  end
+  ( cdh1 - orig ) / step
+end
+
+# Cdh1_activation = TS Cdc14, Cdh1, Cdh1: 1 do |cdc14, cdh1|
+#   x = 1 - cdh1; ( Kah1p + Kah1pp * cdc14 ) * x / ( Jah1 + x ) # orig. formula
+# end
+# Cdh1_inactivation = TS ActCycA, ActCycB, CycD, ActCycE, Cdh1, Cdh1: -1 do
+#   |a, b, d, e, cdh1|
+#   ( Kih1p + Kih1pp * a + Kih1ppp * b + Kih1pppp * e + Kih1ppppp * d ) *
+#     cdh1 / ( Jih1 + cdh1 )
+# end
+
+# === Module 4
+
+CycB_synthesis = TS Vsb, Mass, CycB: 1 do |v, m| v * m end
+CycB_degradation = TS Vdb, CycB, CycB: -1 do |v, b|
+  fod { v }.fine_step( world.simulation.step, 50 ).( b )
+  # v * b
+end
+ActCycB_synthesis = TS Vsb, Mass, ActCycB: 1 do |v, m| v * m end
+
+ActCycB_freeing_due_to_degradation_of_CKI =
+  TS Vdi, CycB, PreMPF, ActCycB, ActCycB: 1 do |v, b, preMPF, actCycB|
+  v * ( b - preMPF - actCycB )
+end
+
+ActCycB_freeing_due_dissoociation_from_CKI =
+  TS CycB, PreMPF, ActCycB, ActCycB: 1 do |b, preMPF, actCycB|
+  Kdib * ( b - preMPF + actCycB )
+end
+
+ActCycB_creation_by_dephosphorylation_of_CycB =
+  TS V25, CycB, TriB, ActCycB, ActCycB: 1 do |v, b, triB, actCycB|
+  v * ( b - triB - actCycB )
+end
+
+ActCycB_phosphorylation_by_Wee1 =
+  TS Vwee, ActCycB, ActCycB: -1 do |v, b| v * b end
+ActCycB_asociation_with_CKI =
+  TS FreeCKI, ActCycB, ActCycB: -1 do |freeCKI, b| freeCKI * b * Kasb end
+ActCycB_degradation = TS Vdb, ActCycB, ActCycB: -1 do |v, b|
+  fod { v }.fine_step( world.simulation.step, 50 ).( b )
+  # v * b
+end
+
+# === Module 5
+
+MPF_phosphorylation = TS Vwee, CycB, PreMPF, PreMPF: 1 do |v, b, preMPF|
+  v * ( b - preMPF )
+end
+
+PreMPF_dephosphorylation =
+  TS V25, PreMPF, PreMPF: -1 do |v, preMPF| v * preMPF end
+PreMPF_degradation =
+  TS Vdb, PreMPF, PreMPF: -1 do |v, preMPF| v * preMPF end
+
+# === Module 6
+
+TriB_assembly = TS CycB, TriB, FreeCKI, TriB: 1 do |b, triB, freeCKI|
+  Kasb * ( b - triB ) * freeCKI
+end
+
+TriB_dissociation =
+  TS TriB: -1, rate: Kdib
+TriB_decrease_due_to_CycB_degradation =
+  TS Vdb, TriB, TriB: -1 do |vdb, triB| vdb * triB end
+TriB_decrease_due_to_CKI_degradation =
+  TS Vdi, TriB, TriB: -1 do |vdi, triB| vdi * triB end
+
+# === Module 8
+
+CKI_synthesis = TS Vsi, CKI: 1 do |v| v end
+
+CKI_degradation = TS Vdi, CKI, CKI: -1 do |v, cki|
+  fod { v }.fine_step( world.simulation.step, 50 ).( cki )
+ # v * cki
+end
+
+# === Module 10
+
+CycE_synthesis =
+  TS TFE, Mass, CycE: 1 do |f, m| ( Ksep + Ksepp * f ) * m end
+
+CycE_degradation = TS Vde, CycE, CycE: -1 do |v, e|
+  # v * e
+  fod { v }.fine_step( world.simulation.step, 50 ).( e )
+end
+
+ActCycE_synthesis =
+  TS TFE, Mass, ActCycE: 1 do |f, m| ( Ksep + Ksepp * f ) * m end
+
+ActCycE_freeing_due_to_degradation_of_CKI =
+  TS Vdi, TriE, ActCycE: 1 do |v, triE| v * triE end
+
+ActCycE_freeing_due_to_dissociation_from_CKI =
+  TS TriE, ActCycE: 1 do |triE| Kdie * triE end
+
+# REMARK: band-aided in CI not to go under 0, fine-stepped here.
+ActCycE_degradation = TS Vde, FreeCKI, ActCycE, ActCycE: -1 do |v, freeCKI, e|
+  # ( v + Kase * freeCKI ) * e
+  fod { v + Kase * freeCKI }.fine_step( world.simulation.step, 50 ).( e )
+end
+
+# === Module 13
+
+CycA_synthesis =
+  TS TFE, Mass, CycA: 1 do |f, m| ( Ksap + Ksapp * f ) * m end
+
+CycA_degradation = TS Vda, CycA, CycA: -1 do |v, a|
+  # v * a
+  fod { v }.fine_step( world.simulation.step, 50 ).( a )
+end
+
+ActCycA_synthesis =
+  TS TFE, Mass, ActCycA: 1 do |f, m| ( Ksap + Ksapp * f ) * m end
+
+ActCycA_freeing_due_to_degradation_of_CKI =
+  TS Vdi, TriA, ActCycE: 1 do |v, triA| v * triA end
+
+ActCycA_freeing_due_to_dissociation_from_CKI =
+  TS TriA, ActCycA: 1 do |triA| Kdia * triA end
+
+# band-aided
+ActCycA_degradation = TS Vda, FreeCKI, ActCycA, ActCycA: -1 do |v, freeCKI, a|
+  # ( v + Kasa * freeCKI ) * a
+  fod { v + Kasa * freeCKI }.fine_step( world.simulation.step, 50 ).( a )
+end
+
+# === finalize
+
+finalize # YNelson command that finishes the net from the prescribed commands.
+
+# ==============================================================================
+# THIS CONCLUDES THE MODEL. COMMANDS BELOW ARE JUST SAVED COMMANDS TO SERVE AS
+# HELP WHEN PERUSING THE MODEL THROUGH THE COMMAND LINE
+# ==============================================================================
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+=begin
+
+# === Whole CELL_CYCLE Nelson net ===
+
+CELL_CYCLE = Net() << A_phase << S_phase << Cdc20A
+
+# === Cell growh net ===
+
+CELL_GROWTH_NET = Net() <<
+  Mass << Cell_growth << CycD << transition( :CycD_ϝ ) << # cell growth
+  CycB << ActCycB <<                                      # cyclin B
+  Ck_license << Cytokinesis << License_cocking            # cytokinesis
+
+set_step 5                                               # simulation settings
+set_sampling 300
+set_target_time 3600 * 24 * 4
+
+new_simulation
+
+
+pm                            # prints marking of the newly created simulation
+simulation.step!              # peforms a single simulation step
+pm                            # prints marking again
+
+# simulation.run! upto: 3600    # we can run 1 hour of this simulation
+
+recording.plot                # and plot the recording
+
+# and do other things with the recording, such as resampling,
+# feature extraction, saving to a file, reconstruction of a new
+# simulation object at a given time etc.
+
+=end

data/lib/cell_cycle/simple.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+# A simplistic cell cycle. It has a single input (Timer place) and 3 outputs
+# (A_phase, S_phase, Cdc20A). A_phase is the phase when the cell cycle enzyme
+# machinery is synthesized. S_phase has the standard meaning: DNA synthesis
+# phase. Cdc20A represents the APC (Anaphase Promoting Complex). When present,
+# it degrades the cell cycle enzyme machinery.
+
+require 'y_nelson' and include YNelson
+require 'sy'
+
+# Constants that control the cell cycle settings.
+S_phase_duration = 12.h
+S_phase_start = 5.h
+S_phase_end = S_phase_start + S_phase_duration
+A_phase_start = 3.h
+A_phase_end = S_phase_end
+Cdc20A_start = 22.h
+Cdc20A_end = 1.h
+
+# Alternative setting for shorter cycle (4.h).
+=begin
+# Constants that control the cell cycle settings.
+S_phase_duration = 4.h
+S_phase_start = 1.h + 40.min
+S_phase_end = S_phase_start + S_phase_duration
+A_phase_start = 1.h
+A_phase_end = S_phase_end
+Cdc20A_start = 7.h + 30.min
+Cdc20A_end = 20.min
+=end
+
+# Figure them out as numbers in seconds.
+Sα = S_phase_start.in :s
+Sω = S_phase_end.in :s
+Aα = A_phase_start.in :s
+Aω = A_phase_end.in :s
+Cdc20Aα = Cdc20A_start.in :s
+Cdc20Aω = Cdc20A_end.in :s
+
+# Timer place
+Timer = Place m!: 0
+
+# The clock transition
+Clock = Transition stoichiometry: { Timer: 1 }, rate: 1
+
+# Empirical places (in arbitrary units); output of the cell cycle.
+A_phase = Place m!: 0
+S_phase = Place m!: 0
+Cdc20A = Place m!: 1
+
+# Include them in the CELL_CYCLE net.
+CELL_CYCLE = Net() << Timer << Clock << A_phase << S_phase << Cdc20A
+
+# Assignment transitions that control the state of the places A_phase, S_phase
+# and Cdc20A.
+# 
+A_phase_ϝ = Transition assignment: -> t { t > Aα && t < Aω ? 1 : 0 },
+                       domain: Timer,
+                       codomain: A_phase
+S_phase_ϝ = Transition assignment: -> t { t > Sα && t < Sω ? 1 : 0 },
+                       domain: Timer,
+                       codomain: S_phase
+Cdc20A_ϝ = Transition assignment: -> t { t < Cdc20Aω || t > Cdc20Aα ? 1 : 0 },
+                      domain: Timer,
+                      codomain: Cdc20A
+
+# Include the A transitions in the CELL_CYCLE net.
+CELL_CYCLE << A_phase_ϝ << S_phase_ϝ << Cdc20A_ϝ
+
+def CELL_CYCLE.default_simulation
+  simulation time: 0..36.h.in( :s ),
+             step: 1.min.in( :s ),
+             sampling: 20.min.in( :s )
+end

data/lib/cell_cycle/version.rb

@@ -0,0 +1,3 @@
+module CellCycle
+  VERSION = "0.0.2"
+end