y_petri 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4924585303a77bc040de2baf135ff544849460ee
-  data.tar.gz: f006c579cc4bc39549b6ff66da0ffcb6ea34bb0a
+  metadata.gz: 7785c5d949ae026d98f538426713dbf8ba5c087b
+  data.tar.gz: ae69a454df83b31f1314dd2935282ab97e12653f
 SHA512:
-  metadata.gz: c041dcddf16daf158db0c602f1ad18c555031d2fe12f3a5c86f728728ea2a950aa8e0c4508bfe4fac13f42c0c4f75570d7f1bb700cbc04a25b6c4b4c6fef2283
-  data.tar.gz: 4636a534a2978c7155b79b0d40f630d01f40d4dc730bb7d46244b85db5ae27f1f08c224c0d11c4b4ae955f4a6fc50ade478354d22aa72498a21dd755ee154bb6
+  metadata.gz: 3a6cb9bc4a188d7de73fd3dd01067772be90ecfbd6f9673fb1adcfee464d590b9d470faeb154d07b89a95e930525ce3c090682817440a23b79829027e5cdf6d8
+  data.tar.gz: fdaed6c9020950aa17a2345567d8fdece08b2987f237aa3448ace6dc75ef14d8f417951ce39690f7de3fab7b24722f0bfcbfe888d151863771ca5f1328f36127

data/.gitignore

@@ -17,4 +17,5 @@ rdoc
 spec/reports
 test/tmp
 test/version_tmp
+test/*.png
 tmp

data/lib/y_petri/manipulator/hash_key_pointer.rb

@@ -0,0 +1,38 @@
+# Represents a pointer to a key of a specific hash associated with the pointer
+# instance. Used to implement pointers of the Manipulator class.
+# 
+class YPetri::Manipulator::HashKeyPointer
+  # Key at which the pointer points.
+  # 
+  attr_reader :key
+
+  # Short text explaining what does a value of the associated hash represent.
+  # 
+  attr_reader :what_is_hash_value
+
+  # Upon initalization, hash key pointer requires a hash, with which the
+  # instance will be associated, a textual description explaining what does
+  # a value of the associated hash represent, and the default hash key.
+  # 
+  def initialize( hash: nil, hash_value_is: '', default_key: nil )
+    @hash = hash
+    @what_is_hash_value = hash_value_is
+    @default_key = default_key
+  end
+
+  # Resets the key to the default key.
+  # 
+  def reset; @key = @default_key end
+
+  # Sets the pointer key to the one given in the argument.
+  # 
+  def set arg; @key = arg end
+
+  # Gets the <em>value</em> paired in the hash associated with the current
+  # key to which this pointer points.
+  # 
+  def get
+    return @hash[@default_key] if @key.nil?
+    @hash[@key] or raise "No #{what_is_hash_value} identified by #{arg}!"
+  end
+end

data/lib/y_petri/manipulator/petri_net_related_methods.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+# Public command interface of YPetri.
+# 
+module YPetri::Manipulator::PetriNetRelatedMethods
+  # Net selection class.
+  # 
+  NetSelection = Class.new YPetri::Manipulator::Selection
+
+  # Net point
+  # 
+  attr_reader :net_point
+
+  # Net selection.
+  # 
+  attr_reader :net_selection
+
+  def initialize
+    net_point_reset
+    @net_selection = NetSelection.new
+    super
+  end
+
+  delegate :place, :transition, :pl, :tr,
+           :places, :transitions, :nets,
+           :pp, :tt, :nn, to: :workspace
+
+  # Place constructor: Creates a new place in the current workspace.
+  # 
+  def Place *args, &b; workspace.Place.new *args, &b end
+
+  # Transiton constructor: Creates a new transition in the current workspace.
+  # 
+  def Transition *args, &b; workspace.Transition.new *args, &b end
+
+  # Net constructor: Creates a new Net instance in the current workspace.
+  # 
+  def Net *args, &b; workspace.Net.new *args, &b end
+
+  # Returns the net identified, or the net at point (if no argument given).
+  # 
+  def net id=nil; id.nil? ? @net_point : workspace.net( id ) end
+
+  # Returns the name of the identified net, or of the net at point (if no
+  # argument given).
+  # 
+  def ne id=nil; net( id ).name end
+
+  # Sets net point to workspace.Net::Top
+  # 
+  def net_point_reset; net_point_set( workspace.Net::Top ) end
+
+  # Sets net point to the net identified by the argument (by name or instance).
+  # 
+  def net_point_set id; @net_point = workspace.net( id ) end
+end # module YPetri::Manipulator::PetriNetRelatedMethods

data/lib/y_petri/manipulator/selection.rb

@@ -0,0 +1,11 @@
+class YPetri::Manipulator::Selection
+  def initialize
+    clear
+  end
+  def clear; @selection = [] end
+  def set *aa; @selection = aa end
+  def get; @selection end
+  def add arg; @selection << arg end
+  alias :<< :add
+  def subtract arg; @selection -= arg end
+end

data/lib/y_petri/manipulator/simulation_related_methods.rb

@@ -0,0 +1,361 @@
+# -*- coding: utf-8 -*-
+# Manipulator instance methods related to simulation (initial marking
+# collections, clamp collections, initial marking collections, management
+# of simulations...)
+# 
+module YPetri::Manipulator::SimulationRelatedMethods
+  require_relative 'hash_key_pointer'
+  require_relative 'selection'
+
+  # Simulation selection class.
+  # 
+  SimulationSelection = Class.new YPetri::Manipulator::Selection
+
+  # Simulation settings collection selection class.
+  # 
+  SscSelection = Class.new YPetri::Manipulator::Selection
+
+  # Clamp collection selection class.
+  # 
+  CcSelection = Class.new YPetri::Manipulator::Selection
+
+  # Initial marking collection selection class.
+  # 
+  ImcSelection = Class.new YPetri::Manipulator::Selection
+
+  class SimulationPoint < YPetri::Manipulator::HashKeyPointer
+    # Reset to the first simulation, or nil if that is absent.
+    # 
+    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).
+    # 
+    def set *args
+      key = identify *args
+      @key = if key.nil? then key
+             elsif @hash.has_key? key then key
+             else raise "No simulation identified by #{key}!" end
+    end
+
+    # Helper method specifying how a simulation is identified by arguments.
+    # 
+    def identify( simulation_name=nil, net: nil, cc: nil, imc: nil, ssc: nil )
+      simulation_name || { net: net, cc: cc, imc: imc, ssc: ssc }
+    end
+  end
+
+  # Pointer to a collection of simulation settings.
+  # 
+  SscPoint = Class.new YPetri::Manipulator::HashKeyPointer
+
+  # Pointer to a clamp collection.
+  # 
+  CcPoint = Class.new YPetri::Manipulator::HashKeyPointer
+
+  # Pointer to a collection of initial markings.
+  # 
+  ImcPoint = Class.new YPetri::Manipulator::HashKeyPointer
+
+  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
+    @simulation_point = SimulationPoint.new( hash: simulations,
+                                             hash_value_is: "simulation" )
+    @ssc_point = SscPoint.new( hash: simulation_settings_collections,
+                                     hash_value_is: "simulation settings collection",
+                                     default_key: :Base )
+    @cc_point = CcPoint.new( hash: clamp_collections,
+                             hash_value_is: "clamp collection",
+                             default_key: :Base )
+    @imc_point = ImcPoint.new( hash: initial_marking_collections,
+                               hash_value_is: "initial marking collection",
+                               default_key: :Base )
+    # set up this manipulator's selections
+    @simulation_selection = SimulationSelection.new
+    @ssc_selection = SscSelection.new
+    @cc_selection = CcSelection.new
+    @imc_selection = ImcSelection.new
+    # do anything else prescribed
+    super
+  end
+
+  # Simulation-related methods delegated to the workspace.
+  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,
+           :set_simulation_settings_collection, :set_ssc,
+           :new_timed_simulation,
+           :clamp_cc, :initial_marking_cc, :simulation_settings_cc,
+           to: :workspace
+
+  # Returns the simulation identified by the argument, or one at simulation
+  # point, if no argument given. The simulation is identified in the same way
+  # as for #simulation_point_to method.
+  # 
+  def simulation *args
+    return simulation_point.get if args.empty?
+    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.
+  # 
+  def clamp_collection id=nil
+    if id.nil? then cc_point.get else clamp_collections[ id ] end
+  end
+  alias cc clamp_collection
+
+  # Returns identified initial marking collection, or (if no argument given)
+  # one corresponding to imc_point.
+  # 
+  def initial_marking_collection id=nil
+    if id.nil? then imc_point.get else
+      initial_marking_collections[ id ]
+    end
+  end
+  alias imc initial_marking_collection
+
+  # Returns identified simulation settings collection, or (if no argument given)
+  # one corresponding to ssc_point.
+  # 
+  def simulation_settings_collection id=nil
+    if id.nil? then ssc_point.get else
+      simulation_settings_collections[ id ]
+    end
+  end
+  alias ssc simulation_settings_collection
+
+  # FIXME: This is going to be tested
+
+  def clamp clamp_hash
+    clamp_hash.each_pair do |place, clamp|
+      clamp_collection.merge! workspace.place( place ) => clamp
+    end
+  end
+
+  # Returns or modifies current initial marking(s) as indicated by the argument
+  # 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.
+  # * 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.
+  # * 2 ordered arguments: First is assumed to identify an imc, second place
+  #   whose im acc. to that imc to return.
+  # 
+  def initial_marking *args;
+    oo = args.extract_options!
+    case args.size
+    when 0 then
+      if oo.empty? then            # no ordered arguments were given,
+        initial_marking_collection # current imc will be returned
+      else # hash was supplied, assumed of pairs { place_id => marking },
+        initial_marking_collection # it will be merged to imc
+          .update( oo.with_keys do |key| place( key ) end )
+      end
+    when 1 then                    # exactly one ordered argument was given,
+      if oo.empty? then            # without any named arguments, it is
+        place = place( args[0] )   # assumed that it identifies a place,
+        initial_marking_collection[ place ] # return its init. marking in imc
+      else # One ordered argument (imc), and one hash (update values) given.
+        im_coll = initial_marking_collection( args[0] )
+        im_coll.update( oo.with_keys do |key| place( key ) end )
+      end
+    when 2 then # 2 ordered arguments (imc, place whose marking to return)
+      im_coll = initial_marking_collection( args[0] )
+      place = place( args[1] )
+      im_coll[ place ]
+    else raise ArgumentError, "Too many ordered parameters" end
+  end
+  alias im initial_marking
+
+  # Changes the time step of the current ssc (ssc = simulation settings
+  # collection).
+  # 
+  def set_step Δt
+    ssc.update step_size: Δt
+  end
+  alias set_step_size set_step
+
+  # Changes the simulation time of the current ssc (ssc = simulation
+  # settings collection).
+  # 
+  def set_time t
+    ssc.update target_time: t
+  end
+  alias set_target_time set_time
+
+  # Changes the sampling period of the current ssc (ssc = simulation
+  # settings collection).
+  # 
+  def set_sampling Δt
+    ssc.update sampling_period: Δt
+  end
+
+  # Changes the simulation method of the current ssc (ssc = simulation
+  # settings collection).
+  # 
+  def set_simulation_method m
+    ssc.update method: m
+  end
+
+  # 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 )
+    # Set the point to it
+    simulation_point.set( simulations.rassoc( instance )[0] )
+    return instance
+  end
+
+  # Create a new timed simulation and run it.
+  # 
+  def run!
+    new_timed_simulation.run!
+  end
+
+  # Write the recorded samples in a file (csv).
+  # 
+  def print_recording( filename = nil )
+    if filename.nil? then
+      puts simulation.recording_csv_string
+    else
+      File.open( filename, "w" ) do |f|
+        f << simulation.recording_csv_string
+      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
+
+  # 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
+    # Decide abnout the features
+    features = sim.places.dup.map { |p|
+      collection.include?( p ) ? p : nil
+    }
+    # 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: "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" )
+  end
+
+  # 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
+    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
+    end
+    # Time axis
+    ᴛ = sim.target_time
+    # Gnuplot call
+    gnuplot( ᴛ, features.compact.map( &:name ), time_series.compact,
+             title: "Flux plot", ylabel: "Flux [µMⁿ.s⁻¹]" )
+  end
+
+  private
+
+  # Gnuplots things.
+  # 
+  def gnuplot( time, labels, time_series, *args )
+    labels = labels.dup
+    time_series = time_series.dup
+    oo = args.extract_options!
+
+    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
+        }
+      end
+    end
+  end
+end # module YPetri::Manipulator