y_petri 2.0.15 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c819010da78d8924cb320612edc32744c5d745a
-  data.tar.gz: f3320f25920735b13fa67be3793fa3dd768915fc
+  metadata.gz: 2b031424367891fe4ff8af4b6c61afb984f5d341
+  data.tar.gz: adb9f8df5d999a60beff42aa1f69fa9aed7f0a7a
 SHA512:
-  metadata.gz: e65d106f512773919f4fcf810927ac7f61c8c0e50c0faeea4b23c7671b2ae175a770ef8ce4da9d08366eb14b55e021b7949965b9c55de7f86f501d8f25128561
-  data.tar.gz: 834d55aeb5103d792a2ff8370352802278815fea76c6286bb465e59973a9e9166c24bce73309d20da1ca85303581cf0ac5cfc015c763f26a3287024dcbc37cdc
+  metadata.gz: ed934ecfc8a78e32d65b8174fee3eedab5ee969ae857b847698581ca3b33e002a4ead151e361caa2d14593efaf44d3d8b04b49f4c286f2a72173bd36c1314a25
+  data.tar.gz: c4fabc8dcf91e509e249dab7e0af4afb97ec2dc8d2b93b5bd18936e408915913e96ef45eb53756b34767257dff0d842194af6a992354e68f183facbad3b05f15

data/lib/y_petri/{manipulator → agent}/hash_key_pointer.rb

@@ -1,7 +1,7 @@
 # Represents a pointer to a key of a specific hash associated with the pointer
-# instance. Used to implement pointers of the Manipulator class.
+# instance. Used to implement pointers of the Agent class.
 # 
-class YPetri::Manipulator::HashKeyPointer
+class YPetri::Agent::HashKeyPointer
   # Key at which the pointer points.
   # 
   attr_reader :key

data/lib/y_petri/agent/petri_net_related.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+# Public command interface of YPetri.
+# 
+module YPetri::Agent::PetriNetRelated
+  # Net selection class.
+  # 
+  NetSelection = Class.new YPetri::Agent::Selection
+
+  # Net point
+  # 
+  attr_reader :net_point
+
+  # Net selection.
+  # 
+  attr_reader :net_selection
+
+  def initialize
+    net_point_reset
+    @net_selection = NetSelection.new
+    super
+  end
+
+  # Elements and selections:
+  # 
+  delegate :place, :transition, :element, 
+           :nets, :places, :transitions,
+           to: :world
+
+  # Place name.
+  # 
+  def pl( place_id )
+    place( place_id ).name
+  end
+
+  # Transition name.
+  # 
+  def tr( transition_id )
+    transition( transition_id ).name
+  end
+
+  # Place names.
+  # 
+  def pn
+    places.names
+  end
+
+  # Transition names.
+  # 
+  def tn
+    transitions.names
+  end
+
+  # Net names.
+  # 
+  def nn
+    nets.names
+  end
+
+  # Place constructor: Creates a new place in the current world.
+  # 
+  def Place( *ordered_args, **named_args, &block )
+    fail ArgumentError, "If block is given, :guard named argument " +
+      "must not be given!" if named_args.has? :guard if block
+    named_args.update( guard: block ) if block # use block as a guard
+    named_args.may_have :default_marking, syn!: :m!
+    named_args.may_have :marking, syn!: :m
+    world.Place.new *ordered_args, **named_args
+  end
+
+  # Transition constructor: Creates a new transition in the current world.
+  # 
+  def Transition( *ordered, **named, &block )
+    world.Transition.new *ordered, **named, &block
+  end
+
+  # Timed transition constructor: Creates a new timed transition in the current
+  # world. Rate closure has to be supplied as a block.
+  # 
+  def T( *ordered, **named, &block )
+    world.Transition.new *ordered, **named.update( rate: block )
+  end
+
+  # Assignment transition constructor: Creates a new assignment transition in
+  # the current world. Assignment closure has to be supplied as a block.
+  # 
+  def A( *ordered, **named, &block )
+    world.Transition.new *ordered,
+                         **named.update( assignment: true, action: block )
+  end
+
+  # Net constructor: Creates a new Net instance in the current world.
+  # 
+  def Net *ordered, **named, &block
+    world.Net.new *ordered, **named, &block
+  end
+
+  # Returns the net identified, or the net at point (if no argument given).
+  # 
+  def net id=nil
+    id.nil? ? @net_point : world.net( id )
+  end
+
+  # Sets the net point to a given net, or to world.Net::Top if none given.
+  # 
+  def net_point_reset id=world.Net::Top
+    @net_point = world.net( id )
+  end
+
+  # Sets net point to a given net.
+  # 
+  def net_point= id
+    net_point_reset id
+  end
+end # module YPetri::Agent::PetriNetRelated

data/lib/y_petri/{manipulator → agent}/selection.rb

@@ -1,4 +1,5 @@
-class YPetri::Manipulator::Selection
+class YPetri::Agent::Selection
+  # TODO: This calls for refactor as Array subclass.
   def initialize
     clear
   end

data/lib/y_petri/{manipulator/simulation_related_methods.rb → agent/simulation_related.rb}

@@ -1,32 +1,34 @@
-# -*- coding: utf-8 -*-
-# Manipulator instance methods related to simulation (initial marking
-# collections, clamp collections, initial marking collections, management
-# of simulations...)
+# encoding: utf-8
+
+# Agent instance methods related to simulation (initial marking collections,
+# clamp collections, initial marking collections, management of simulations...)
 # 
-module YPetri::Manipulator::SimulationRelatedMethods
+module YPetri::Agent::SimulationRelated
   require_relative 'hash_key_pointer'
   require_relative 'selection'
 
   # Simulation selection class.
   # 
-  SimulationSelection = Class.new YPetri::Manipulator::Selection
+  SimulationSelection = YPetri::Agent::Selection.parametrize agent: self
 
   # Simulation settings collection selection class.
   # 
-  SscSelection = Class.new YPetri::Manipulator::Selection
+  SscSelection = YPetri::Agent::Selection.parametrize agent: self
 
   # Clamp collection selection class.
   # 
-  CcSelection = Class.new YPetri::Manipulator::Selection
+  CcSelection = YPetri::Agent::Selection.parametrize agent: self
 
   # Initial marking collection selection class.
   # 
-  ImcSelection = Class.new YPetri::Manipulator::Selection
+  ImcSelection = YPetri::Agent::Selection.parametrize agent: self
 
-  class SimulationPoint < YPetri::Manipulator::HashKeyPointer
+  class SimulationPoint < YPetri::Agent::HashKeyPointer
     # Reset to the first simulation, or nil if that is absent.
     # 
-    def reset; @key = @hash.empty? ? nil : set( @hash.first[0] ) end
+    def reset
+      @key = @hash.empty? ? nil : set( @hash.first[0] )
+    end
 
     # A simulation is identified either by its name (if named), or by its
     # parameters and settings (:net, :cc, :imc, :ssc).
@@ -47,19 +49,24 @@ module YPetri::Manipulator::SimulationRelatedMethods
 
   # Pointer to a collection of simulation settings.
   # 
-  SscPoint = Class.new YPetri::Manipulator::HashKeyPointer
+  SscPoint = YPetri::Agent::HashKeyPointer.parametrize agent: self
 
   # Pointer to a clamp collection.
   # 
-  CcPoint = Class.new YPetri::Manipulator::HashKeyPointer
+  CcPoint = YPetri::Agent::HashKeyPointer.parametrize agent: self
 
   # Pointer to a collection of initial markings.
   # 
-  ImcPoint = Class.new YPetri::Manipulator::HashKeyPointer
+  ImcPoint = YPetri::Agent::HashKeyPointer.parametrize agent: self
 
-  attr_reader :simulation_point, :ssc_point, :cc_point, :imc_point,
-              :simulation_selection, :ssc_selection,
-              :cc_selection, :imc_selection
+  attr_reader :simulation_point,
+              :ssc_point,
+              :cc_point,
+              :imc_point,
+              :simulation_selection,
+              :ssc_selection,
+              :cc_selection,
+              :imc_selection
 
   def initialize
     # set up this manipulator's pointers
@@ -83,20 +90,20 @@ module YPetri::Manipulator::SimulationRelatedMethods
     super
   end
 
-  # Simulation-related methods delegated to the workspace.
+  # Simulation-related methods delegated to the world.
   delegate :simulations,
            :clamp_collections,
            :initial_marking_collections,
            :simulation_settings_collections,
-           :clamp_collection_names, :cc_names,
-           :initial_marking_collection_names, :imc_names,
-           :simulation_settings_collection_names, :ssc_names,
-           :set_clamp_collection, :set_cc,
-           :set_initial_marking_collection, :set_imc,
+           :clamp_collection_names, :ncc,
+           :initial_marking_collection_names, :nimc,
+           :simulation_settings_collection_names, :nssc,
+           :set_clamp_collection, :ncc,
+           :set_initial_marking_collection, :nimc,
            :set_simulation_settings_collection, :set_ssc,
-           :new_timed_simulation,
+           :new_simulation,
            :clamp_cc, :initial_marking_cc, :simulation_settings_cc,
-           to: :workspace
+           to: :world
 
   # Returns the simulation identified by the argument, or one at simulation
   # point, if no argument given. The simulation is identified in the same way
@@ -107,10 +114,6 @@ module YPetri::Manipulator::SimulationRelatedMethods
     SimulationPoint.new( hash: simulations, hash_value_is: "simulation" ).get
   end
 
-  # # TEMPORARY KLUGE - FIXME
-  # # 
-  # def simulation; @workspace.simulations.values[-1] end
-
   # Returns identified clamp collection, or (if no argument given) one
   # corresponding to cc_point.
   # 
@@ -143,7 +146,7 @@ module YPetri::Manipulator::SimulationRelatedMethods
 
   def clamp clamp_hash
     clamp_hash.each_pair do |place, clamp|
-      clamp_collection.merge! workspace.place( place ) => clamp
+      clamp_collection.merge! world.place( place ) => clamp
     end
   end
 
@@ -151,7 +154,7 @@ module YPetri::Manipulator::SimulationRelatedMethods
   # field:
   # * No arguments: returns current imc
   # * Exactly one ordered argument: it is assumed to identify a place whose
-  #   im in teh current imc will be returned.
+  #   im in the current imc will be returned.
   # * A hash: Assumed to be { place_id => im }, current imc is updated with it.
   # * One ordered argument, and a hash: The imc identified by the ordered
   #   ordered arg is updated with the hash.
@@ -222,8 +225,8 @@ module YPetri::Manipulator::SimulationRelatedMethods
   # Create a new timed simulation and make it available in the simulations
   # table.
   # 
-  def new_timed_simulation *args, &block
-    instance = workspace.new_timed_simulation( *args, &block )
+  def new_simulation *args, &block
+    instance = world.new_simulation( *args, &block )
     # Set the point to it
     simulation_point.set( simulations.rassoc( instance )[0] )
     return instance
@@ -232,43 +235,37 @@ module YPetri::Manipulator::SimulationRelatedMethods
   # Create a new timed simulation and run it.
   # 
   def run!
-    new_timed_simulation.run!
+    new_simulation.run!
   end
 
   # Write the recorded samples in a file (csv).
   # 
-  def print_recording( filename = nil )
+  def print_recording( filename=nil )
     if filename.nil? then
-      puts simulation.recording_csv_string
+      puts simulation.recording.to_csv
     else
       File.open( filename, "w" ) do |f|
-        f << simulation.recording_csv_string
+        f << simulation.recording.to_csv
       end
     end
   end
 
   # Plot the recorded samples.
   # 
-  def plot *args
-    oo = args.extract_options!
-    case args.size
-    when 0 then plot_recording oo
-    when 1 then
-      plot_what = args[0]
-      case plot_what
-      when :state then plot_recording oo
-      when :flux then plot_flux oo
-      when :all then plot_all oo
-      else plot_selected *args end
-    else raise "Too many ordered arguments!" end
-  end
+  def plot **features
+    # --> state feature ids
+    # --> gradient feature ids
+    # --> delta feature ids
+    # --> flux feature ids
+    # --> firing feature ids
 
-  # Plot the selected features.
-  # 
-  def plot_selected *args
-    oo = args.extract_options!
-    collection = Array args[0]
-    return nil unless sim = @workspace.simulations.values[-1] # sim@point
+    # take these features together
+
+    # construct the labels and the time series for each
+
+    # plot them
+
+    return nil unless sim = world.simulations.values[-1] # sim@point
     # Decide abnout the features
     features = sim.places.dup.map { |p|
       collection.include?( p ) ? p : nil
@@ -285,82 +282,68 @@ module YPetri::Manipulator::SimulationRelatedMethods
     gnuplot( ᴛ, features.compact.map( &:name ), time_series.compact,
              title: "Selected features plot", ylabel: "Marking" )
   end
-    
 
   # Plot the recorded samples (system state history).
   # 
-  def plot_state( *args )
-    oo = args.extract_options!
-    excluded = Array oo[:except]
-    return nil unless sim = @workspace.simulations.values[-1] # sim@point
-    # Decide about the features to plot.
-    features = excluded.each_with_object sim.places.dup do |x, α|
-      i = α.index x
-      α[i] = nil if i
-    end
-    # Get recording
-    rec = sim.recording
-    # Select a time series for each feature.
-    time_series = features.map.with_index do |feature, i|
-      feature and rec.map { |key, val| [ key, val[i] ] }.transpose
-    end
-    # Time axis
-    ᴛ = sim.target_time
-    # Gnuplot call
-    gnuplot( ᴛ, features.compact.map( &:name ), time_series.compact,
-             title: "State plot", ylabel: "Marking" )
+  def plot_state( place_ids=nil, except: [] )
+    sim = simulation or return nil
+    feat = sim.pp( place_ids || sim.pp ) - sim.pp( Array except )
+    gnuplot sim.record.marking( feat ), time: sim.target_time,
+            title: "State plot", ylabel: "Marking"
   end
+  alias plot_marking plot_state
 
   # Plot the recorded flux (computed flux history at the sampling points).
   # 
-  def plot_flux( *args )
-    oo = args.extract_options!
-    excluded = Array oo[:except]
-    return nil unless sim = @workspace.simulations.values[-1] # sim@point
-    # Decide about the features to plot.
-    all = sim.SR_transitions
-    features = excluded.each_with_object all.dup do |x, α|
-      i = α.index x
-      if i then α[i] = nil end
+  def plot_flux( transition_ids=nil, **options )
+    sim = world.simulations.values[-1] or return nil # sim@point
+    tt = sim.TS_transitions( transition_ids ).sources
+    excluded = sim.transitions( Array options[:except] ).sources
+    tt -= excluded
+    flux = sim.recording.modify do |time, record|
+      [ time,
+        sim.at( time: time, marking: record ).TS_transitions( tt ).flux_vector ]
     end
-    # Get recording.
-    rec = sim.recording
-    # Get flux recording.
-    flux = rec.modify { |ᴛ, ᴍ| [ ᴛ, sim.at( t: ᴛ, m: ᴍ ).flux_for( *all ) ] }
     # Select a time series for each feature.
-    time_series = features.map.with_index do |feature, i|
-      feature and flux.map { |ᴛ, flux| [ ᴛ, flux[i] ] }.transpose
+    time_series = tt.map.with_index do |tr, i|
+      tr and flux.map { |time, flux| [ time, flux[i] ] }.transpose
     end
     # Time axis
-    ᴛ = sim.target_time
+    time = sim.target_time
     # Gnuplot call
-    gnuplot( ᴛ, features.compact.map( &:name ), time_series.compact,
+    gnuplot( time, tt.compact.names, time_series.compact,
              title: "Flux plot", ylabel: "Flux [µMⁿ.s⁻¹]" )
   end
 
   private
 
-  # Gnuplots things.
+  # Gnuplots a recording. Target time or time range can be supplied as :time
+  # named argument.
   # 
-  def gnuplot( time, labels, time_series, *args )
-    labels = labels.dup
-    time_series = time_series.dup
-    oo = args.extract_options!
+  def gnuplot( dataset, time: nil, **nn )
+    event_vector = dataset.events
+    data_vectors = dataset.values.transpose
+    x_range = if time.is_a? Range then
+                "[#{time.begin}:#{time.end}]"
+              else
+                "[-0:#{SY::Time.magnitude( time ).amount rescue time}]"
+              end
+    labels = recording.features.labels
 
     Gnuplot.open do |gp|
       Gnuplot::Plot.new( gp ) do |plot|
-        plot.xrange "[-0:#{SY::Time.magnitude( time ).amount rescue time}]"
-        plot.title oo[:title] || "Simulation plot"
-        plot.ylabel oo[:ylabel] || "Values"
-        plot.xlabel oo[:xlabel] || "Time [s]"
-
-        labels.zip( time_series ).each { |label, series|
-          plot.data << Gnuplot::DataSet.new( series ) do |data_series|
-            data_series.with = "linespoints"
-            data_series.title = label
-          end
+        plot.xrange x_range
+        plot.title nn[:title] || "Simulation plot"
+        plot.ylabel nn[:ylabel] || "Values"
+        plot.xlabel nn[:xlabel] || "Time [s]"
+
+        labels.zip( data_vectors ).each { |label, data_vector|
+          plot.data << Gnuplot::DataSet.new( [event_vector, data_vector] ) { |ds|
+            ds.with = "linespoints"
+            ds.title = lbl
+          }
         }
       end
     end
   end
-end # module YPetri::Manipulator
+end # module YPetri::Agent::SimulationRelated

data/lib/y_petri/agent.rb

@@ -0,0 +1,22 @@
+#encoding: utf-8
+
+# Public command interface of YPetri.
+# 
+module YPetri
+  class Agent
+    attr_reader :world
+
+    def initialize
+      @world = YPetri::World.new
+      super
+    end
+
+    require_relative 'agent/selection'
+    require_relative 'agent/hash_key_pointer'
+    require_relative 'agent/petri_net_related'
+    require_relative 'agent/simulation_related'
+
+    include self::PetriNetRelated
+    include self::SimulationRelated
+  end # class Agent
+end # module YPetri

data/lib/y_petri/core/timed/euler.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+# Euler method.
+# 
+class YPetri::Core::Timed
+  module Euler
+    # Name of this method.
+    # 
+    def simulation_method
+      :euler
+    end
+
+    # Computes Δ for the period of Δt.
+    # 
+    def delta Δt
+      gradient * Δt
+    end
+    alias Δ delta
+  end # Euler
+end # YPetri::Core::Timed

data/lib/y_petri/core/timed/pseudo_euler.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+# Euler method with timeless transitions firing after each step.
+# 
+class YPetri::Core::Timed
+  module PseudoEuler
+    include Euler
+
+    # Name of this method.
+    # 
+    def simulation_method
+      :pseudo_euler
+    end
+
+    # Computes Δ for the period of Δt.
+    # 
+    def delta Δt
+      super + delta_timeless
+    end
+    alias Δ delta
+
+    # Makes a single step by Δt.
+    # 
+    def step! Δt=simulation.step
+      increment_marking_vector Δ( Δt )
+      assignment_transitions_all_fire!
+      simulation.increment_time! Δt
+      alert
+    end
+  end # PseudoEuler
+end # YPetri::Core::Timed

data/lib/y_petri/core/timed/quasi_euler.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+# Euler method with timeless transitions firing every time tick.
+# 
+class YPetri::Core::Timed
+  module QuasiEuler
+    include Euler
+
+    # Name of this method.
+    # 
+    def simulation_method
+      :quasi_euler
+    end
+
+    # Makes a single step by Δt.
+    # 
+    def step! Δt=simulation.step_size
+      fail NotImplementedError
+      # Now one would have to compare whichever comes first, time tick or the
+      # end of Δt, and then again and again, until Δt is fired...
+    end
+  end # QuasiEuler
+end # YPetri::Core::Timed

data/lib/y_petri/core/timed.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+# Timed simulation core.
+# 
+class YPetri::Core
+  class Timed < YPetri::Core
+    require_relative 'timed/euler.rb'
+    require_relative 'timed/pseudo_euler.rb' # timeless fire after each step
+    require_relative 'timed/quasi_euler.rb'  # timeless fire each time tick
+
+    # Makes a single step by Δt.
+    # 
+    def step! Δt=simulation.step
+      increment_marking_vector Δ( Δt )
+      increment_time! Δt
+      note_state_change
+    end
+
+    # Gradient for free places.
+    # 
+    def gradient
+      gradient_Ts + gradient_TS
+    end
+    alias ∇ gradient
+
+    # Gradient contribution by Ts transitions.
+    # 
+    def gradient_Ts
+      simulation.Ts_gradient_closure.call
+    end
+
+    # Gradient contribution by TS transitions.
+    # 
+    def gradient_TS
+      ( simulation.TS_stoichiometry_matrix * flux_vector_TS )
+    end
+
+    # Flux vector. The caller asserts that all the timed transitions are
+    # stoichiometric, or error.
+    # 
+    def flux_vector
+      msg = "#flux_vector method only applies to the timed simulations with " +
+        "no Ts transitions. Try #flux_vector_TS instead!"
+      fail msg unless Ts_transitions().empty?
+      simulation.TS_rate_closure.call
+    end
+
+    # Flux vector of TS transitions.
+    # 
+    def flux_vector_TS
+      simulation.TS_rate_closure.call
+    end
+  end # class Timed
+end # class YPetri::Core
+
+# In general, it is not required that all net elements are simulated with the
+# same method. Practically, ODE systems have many good simulation methods
+# available.
+#
+# (1) ᴍ(t) = ϝ f(ᴍ, t).dt, where f(ᴍ, t) is a known function.
+#
+# Many of these methods depend on the Jacobian, but that may not be available
+# for some places. Therefore, the places, whose marking defines the system
+# state, are divided into two categories: "A" (accelerated), for which as
+# common Jacobian can be found, and "E" places, where "E" can stand either for
+# "External" or "Euler".
+#
+# If we apply the definition of "causal orientation" on A and E places, then it
+# can be said, that only the transitions causally oriented towards "A" places
+# are allowed for compliance with the equation (1).

data/lib/y_petri/core/timeless/pseudo_euler.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+# Implicit Euler for timeless nets. Simply, timeless transitions
+# fire simultaneously, after which A transitions (if any) fire.
+#
+class YPetri::Core::Timeless
+  module PseudoEuler
+    # Name of this method.
+    # 
+    def simulation_method
+      :pseudo_euler
+    end
+
+    def step!
+      increment_marking_vector Δ
+      assignment_transitions_all_fire!
+      alert
+    end
+  end # module PseudoEuler
+end # class YPetri::Core::Timeless

data/lib/y_petri/core/timeless.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+# Timeless simulation core.
+# 
+class YPetri::Core
+  class Timeless < YPetri::Core
+    require_relative 'timeless/pseudo_euler'
+
+    alias delta delta_timeless
+    alias Δ delta
+  end # class Timeless
+end # class YPetri::Core