trinitycrdriver 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99d128788dbcf852da53d869d20f874b57cdb6b4
-  data.tar.gz: eca654dc62344fc0f941784cb60c3c65b6779ea5
+  metadata.gz: be3b3ef7a8135177b9176f17971baf754f62c114
+  data.tar.gz: 26d256bd34c004714b8ad5e0b7f035ef235110b3
 SHA512:
-  metadata.gz: 9098ed22b3dd3371c01c81728d3d83d8c6b11b3f51d0058c4dab0bc2926e2a8e0e9f4e1135b5f6e71fb9d5408cf86f8c2d5b63a37a06a891a4a9e70dce5c0523
-  data.tar.gz: 1a726053cdedf417eefa3b2634536592bdd5089c7781b5cbd125bb88af2e093aee0ef16582e4498cd8945c6bf0e550d0e56a895d31fe45f4573044432a44f0b0
+  metadata.gz: fb01d0c800b4abaa758b6739012aa4d5d244fd9325b29ce540d972cb82302d14675f0114144657520737aae6153403d28e1923a07fc47993a614edc58e929fc3
+  data.tar.gz: 1bf6596bb2b92870736be15126f7cf1e1eda6d8dd8326b7185efe0baf576e22e648e670da8578be262b500e7fb2693f2b91d4da58e5b564da0bc237fb8dbb0c7

data/Gemfile

@@ -4,9 +4,10 @@ source "http://rubygems.org"
    gem "coderunner", ">= 0.14.2"
    gem "text-data-tools", ">= 1.1.3"
 	 gem "gs2crmod", ">=0.11.33"
-	 gem "trinitycrmod", ">= 0.4.7"
+	 gem "trinitycrmod", ">= 0.7.11"
 	 gem "ruby-mpi", ">=0.2.0"
 	 gem "cheasecrmod", ">=0.1.0"
+   gem "tokfile", ">=0.0.3"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/lib/trinitycrdriver.rb

@@ -4,12 +4,20 @@ class CodeRunner
     module TrinityDriver                                                                         
       extend FFI::Library                                                                        
       ffi_lib ENV['TRINITY'] + '/libtrin.so'                                                     
-      attach_function :runtr, :run_trinity_c, [:string, :int], :void                       
+      attach_function :runtr, :run_trinity_c, [:string, :size_t], :void                       
+      attach_function :runtr2, :run_trinity_test, [], :void                       
     end 
     def run_trin_actual2(input_file, mpicomm_int)
-      puts 'calling TrinityDriver.runtr'
+      puts ['calling TrinityDriver.runtr',mpicomm_int.class]
       TrinityDriver.runtr(input_file, mpicomm_int)
     end
+    def self.run_trin_standalone(input_file)
+      require 'mpi'
+      MPI.Init
+      obj = CodeRunner::Trinity.new
+      obj.run_trinity(input_file, MPI::Comm::WORLD)
+      MPI.Finalize
+    end
     private :run_trin_actual2
   end
 end
@@ -21,8 +29,12 @@ class CodeRunner::Trinity
 	# Instead of running trinity via a bash command or a batch script,
 	# we run it directly via its API.
 	@delay_execution = false
+  def queue_status
+    ""
+  end
 	def execute
 		if rcp.delay_execution
+      eputs 'Delaying execution...'
 			return
 		else
 			execute_actual

data/lib/trinitycrdriver/optimisation.rb

@@ -1,109 +1,342 @@
+CodeRunner.setup_run_class('chease')
 
+class CodeRunner::Chease
+  # We hotwire the execute command so that it just
+  # runs it instead of doing a batch submission
+  def execute
+    system "#{executable}"
+  end
+end
+class CodeRunner::Ecom
+  # We hotwire the execute command so that it just
+  # runs it instead of doing a batch submission
+  def execute
+    system "#{executable}"
+  end
+end
 class CodeRunner::Trinity::Optimisation
   include GSL::MultiMin
-    # optimisation_spec is a hash of {:code_name => {:variable => [initial_guess, dimension_scale_factor]}}
-    # dimension_scale_factor is just some estimate of the length scale in which the result
-    # varies significantly
+  # optimisation_spec is a hash of {:code_name => {:variable => [initial_guess, dimension_scale_factor]}}
+  # dimension_scale_factor is just some estimate of the length scale in which the result
+  # varies significantly
   # code_name is either trinity or chease (both can be used simultaneously)
-    attr_reader :optimisation_spec
-    attr_reader :optimisation_variables
-    attr_accessor :trinity_runner
-    attr_accessor :chease_runner
-    def initialize(optimised_quantity, optimisation_spec)
-      #@folder = folder
-      @optimised_quantity = optimised_quantity
-      @optimisation_spec = optimisation_spec
-      @optimisation_variables = optimisation_spec.map{|code, hash| hash.map{|var, pars| [code, var]}}.flatten(1)
-      @optimisation_starts    = optimisation_spec.map{|code, hash| hash.map{|var, pars| pars[0]}}.flatten(1)
-      @optimisation_steps     = optimisation_spec.map{|code, hash| hash.map{|var, pars| pars[1]}}.flatten(1)
-      #@runner = CodeRunner.fetch_runner(
-      #p ['optimisation_variables', @optimisation_variables]
-    end
-    def dimension
-      @optimisation_variables.size
-    end
-    def serial_optimise(optimisation_method, parameters_obj)
-      optimisation_meth = case optimisation_method
-                          when :simplex
-                            FMinimizer::NMSIMPLEX
-                          else 
-                            raise "Unknown optimisation_method"
-                          end
-      opt = FMinimizer.alloc(optimisation_meth, @optimisation_variables.size)
+  attr_reader :optimisation_spec
+  attr_reader :optimisation_variables
+  attr_accessor :trinity_runner
+  attr_accessor :gs_runner
+  attr_accessor :parameters_obj
+  attr_accessor :results_hash
+  def initialize(optimised_quantity, optimisation_spec)
+    #@folder = folder
+    @optimised_quantity = optimised_quantity
+    @optimisation_spec = optimisation_spec
+    @optimisation_variables = optimisation_spec.map{|code, hash| hash.map{|var, pars| [code, var]}}.flatten(1)
+    @optimisation_starts    = optimisation_spec.map{|code, hash| hash.map{|var, pars| pars[0]}}.flatten(1)
+    @optimisation_steps     = optimisation_spec.map{|code, hash| hash.map{|var, pars| pars[1]}}.flatten(1)
+    #@runner = CodeRunner.fetch_runner(
+    #p ['optimisation_variables', @optimisation_variables]
+    @results_hash = {}
+    @first_call = true
+    @ifspppl_converged = false
+  end
+  def dimension
+    @optimisation_variables.size
+  end
+  def serial_optimise(optimisation_method, parameters_obj)
+    optimisation_meth = case optimisation_method
+                        when :simplex
+                          FMinimizer::NMSIMPLEX
+                        else 
+                          raise "Unknown optimisation_method"
+                        end
+    @results_hash[:start_time] = Time.now.to_i
+    opt = FMinimizer.alloc(optimisation_meth, @optimisation_variables.size)
+    @parameters_obj = parameters_obj
+    catch(:out_of_time) do 
       func = Proc.new{|v, optimiser| optimiser.func(v)}
+      eputs 'Created func'
       gsl_func = Function.alloc(func, dimension)
+      eputs 'Allocated gsl_func'
       gsl_func.set_params(self)
+      eputs 'Set params'
       opt.set(gsl_func, @optimisation_starts.to_gslv, @optimisation_steps.to_gslv)
+      eputs 'Set func and starting iteration'
       parameters_obj.nit.times do |i|
         opt.iterate
         p ['status', opt.x, opt.minimum, i, parameters_obj.nit]
+        @results_hash[:iterations] ||= []
+        @results_hash[:iterations].push [opt.x.dup, opt.minimum]
+        @results_hash[:elapse_mins] = (Time.now.to_i - @results_hash[:start_time]).to_f/60
+        @results_hash[:current_time] = Time.now.to_i
+        File.open('results', 'w'){|f| f.puts @results_hash.pretty_inspect}
+      end
+      eputs 'Optimisation complete'
+    end
+    eputs 'Optimisation ended'
+    #MPI.Finalize
+
+  end
+  def func(v)
+    val = nil
+    count = 1
+    val_old, repeat = func_actual(v)
+    loop do
+      val, repeat, trinity_is_converged = func_actual(v)
+      if trinity_is_converged # This means that Trinity has reached steady state
+
+        # Now we check if the loop over recalculating the GS equation
+        # has converged
+        if ((val_old - val)/val).abs < @parameters_obj.convergence
+          if @parameters_obj.use_ifspppl_first and not @ifspppl_converged
+            @ifspppl_converged = true
+          else 
+            break
+          end
+        end
+        break if count > @parameters_obj.max_func_evals
+
+        # If geometry is being evolved internally in Trinity, we don't
+        # need to run this loop
+        break if not repeat
+        val_old = val
+        #break if not repeat or (not @first_call and count > 1) or count > 4
+        count += 1 unless @parameters_obj.use_ifspppl_first and not @ifspppl_converged
       end
+    end
+    @first_call = false
+    return val
+  end
+  def func_actual(v)
+    eputs 'Starting func'
+    @id||=1 # Id of the current trinity run which should always be equal to the number of func_actual calls
+    repeat = false
+    print_pars = {}
+    pars = {}
+    pars[:gs] = {}
+    pars[:trinity] = {}
+    pars[:trinity].absorb(@parameters_obj.trinity_pars) if @parameters_obj.trinity_pars
+    pars[:gs].absorb(@parameters_obj.gs_pars) if @parameters_obj.gs_pars
+    for i in 0...v.size
+      code, varname = @optimisation_variables[i]
+      val = v[i]
+      code = case code
+             when :chease, :ecom
+               :gs
+             else
+               :trinity
+             end
+      pars[code][varname] = val
+      print_pars[code] ||={}
+      print_pars[code][varname] = val
+    end
+    if not @first_run_done
+      pars[:trinity][:ntstep] = @parameters_obj.ntstep_first
+      #pars[:trinity][:nifspppl_initial] = -1
+      #pars[:trinity][:niter] = 2
+
+      # The line below assumes that the whole first run is done
+      # with ifspppl, in which case we don't want the timestep to get 
+      # too large for the gryfx run afterwards.
+      #pars[:trinity][:ntdelt_max] = 0.05
+      #pars[:trinity][:convergetol] = -1.0
+    else
+      pars[:trinity][:ntstep] = @parameters_obj.ntstep
+      #pars[:trinity][:nifspppl_initial] = -1
+      #pars[:trinity][:niter] = 3
+      #pars[:trinity][:ntdelt_max] = 10.0
+    end
+    if @parameters_obj.use_ifspppl_first and not @ifspppl_converged
+      pars[:trinity][:nifspppl_initial] = pars[:trinity][:ntstep]
+    else
+      pars[:trinity][:nifspppl_initial] = -1
+    end
+
+
+    # Must fix this soon!
+    if @parameters_obj.gs_code == 'chease'
+      #pars[:gs][:ap] = [0.3,0.5,0.4,0.0,0.4,0.0,0.0]
+      #pars[:gs][:at] = [0.16,1.0,1.0,-1.1,-1.1]
+    end
 
-      p 'heellllllo'
-      MPI.Finalize
-      
+    trinity_runner.run_class.instance_variable_set(:@mpi_communicator, MPI::Comm::WORLD)
+    #if false and trinity_runner.run_list.size > 0
+    #else
+    if @first_run_done
+      #crun.nppfun=4
+      #crun.neqdsk=0
+      #crun.expeq_file = trinity_runner.run_list[@id]
     end
-    def func(v)
-      pars = {}
-      pars[:chease] = {}
-      pars[:trinity] = {}
-      for i in 0...v.size
-        code, varname = @optimisation_variables[i]
-        val = v[i]
-        pars[code][varname] = val
+    if not @replay
+      if not @first_run_done and gs_runner.run_list.size > 0
+        #This means we are in a restart
+        @replay = true
+        @nrun = 1
+        if @parameters_obj.delete_final_run
+          eputs 'Removing final run: ' + trinity_runner.run_list.keys.max.to_s
+          trinity_runner.conditions =  'id==' + trinity_runner.run_list.keys.max.to_s
+          trinity_runner.destroy no_confirm: true
+          gs_runner.conditions =  'id==' + gs_runner.run_list.keys.max.to_s
+          gs_runner.destroy no_confirm: true
+        end
+      else
+        @nrun = nil
+        @replay = false
       end
-      if not @first_run_done
-        pars[:trinity][:ntstep] = 300
+    end
+    if @replay
+      eputs 'Replaying: ' + @nrun.to_s
+      run = trinity_runner.run_list[@nrun]
+      if not run
+        eputs 'Ending replay at ' + @nrun.to_s
+        @replay = false
+        @id = @gsid = @nrun-1
       else
-        #pars[:trinity].delete(:ntstep)
-        pars[:trinity][:ntstep] = 100
+        @id = @gsid = @nrun
       end
+      @nrun += 1
+    end
+    Hash.phoenix('func_calls.rb') do |hash|
+      hash[@id+1] ||={}
+      hash[@id+1][:variables] = v.dup
+      hash[@id+1][:print_pars] = print_pars
+      hash
+    end
+    #raise "WORK!!"
+    eputs "Written parameters"
+    if not @replay
+      eputs "Not replaying... starting GS and Trinity runs"
+      remaining_wall_mins = (
+        @parameters_obj.wall_mins - @parameters_obj.wall_mins_margin -
+        (Time.now.to_i - @parameters_obj.start_time).to_f / 60.0
+      )
+      eputs "Remaining wall mins #{remaining_wall_mins}, wall mins #{@parameters_obj.wall_mins}, start time #{@parameters_obj.start_time}, time #{Time.now.to_i}, margin #{@parameters_obj.wall_mins_margin}"
+      if remaining_wall_mins < @parameters_obj.wall_mins_margin
+        eputs "Run out of time"
+        throw(:out_of_time) 
+      end 
+      eputs "Starting real run, @id = ",@id
+      # Create and initialize the gs run
+      gsrun = gs_runner.run_class.new(gs_runner)
+      raise "No gs_defaults strings" unless @parameters_obj.gs_defaults_strings.size > 0
+      @parameters_obj.gs_defaults_strings.each{|prc| gsrun.instance_eval(prc)}
+      if gs_runner.run_list.size > 0 
+        #gsrun.restart_id = @gsid
+        if @parameters_obj.gs_code == 'chease'
+          last_converged = @id
+          #We need to find the last converged Trinity run to use as the pressure profile.
+          until last_converged == 0 or trinity_runner.combined_run_list[last_converged].is_converged?
+            eputs "Run #{last_converged} not converged"
+            last_converged -= 1
+          end
+          #unless (@parameters_obj.use_previous_pressure==0 and not @first_trinity_run_completed)
+          unless last_converged == 0
+            eputs "Using previous pressure profile"
+            # We give CHEASE the pressure profile from the previous run.
+            pars[:gs][:nppfun] = 4
+            pars[:gs][:nfunc] = 4
+            #if prid = @parameters_obj.use_previous_pressure and not @first_trinity_run_completed
+            # If the last trinity run did not converge we may want to run exactly
+            # the same case again, and in particular use the pressure profile from 
+            # the previous Trinity  run as input (as an unconverged pressure profile
+            # can lead to a wacky GS solution)
+            #gsrun.expeq_in=trinity_runner.combined_run_list[prid].directory + '/chease/EXPEQ.NOSURF'
+            #else
+            gsrun.expeq_in=trinity_runner.combined_run_list[last_converged].directory + '/chease/EXPEQ.NOSURF'
+            #end
+            # Don't optimise presssure profile.
+            pars[:gs][:nblopt] = 0
+          end
+        end
+      end
+      gsrun.update_submission_parameters(pars[:gs].inspect, false)
 
-      pars[:chease][:ap] = [0.3,0.5,0.4,0.0,0.4,0.0,0.0]
-      pars[:chease][:at] = [0.16,1.0,1.0,-1.1,-1.1]
+      # Create and initialize the trinity run
+      run = trinity_runner.run_class.new(trinity_runner)
+      raise "No trinity_defaults_strings" unless @parameters_obj.trinity_defaults_strings.size > 0
+      run.instance_variable_set(:@set_flux_defaults_procs, []) unless run.instance_variable_get(:@set_flux_defaults_procs)
+      @parameters_obj.trinity_defaults_strings.each{|prc| run.instance_eval(prc)}
+      run.update_submission_parameters(pars[:trinity].inspect, false)
 
+      #if @parameters_obj.gs_code == 'chease' and (run.evolve_geometry and run.evolve_geometry.fortran_true?)
+      #pars[:gs][:nblopt] = 0
+      #end
+      gs_runner.submit(gsrun)
+      gsrun = gs_runner.run_list[@gsid = gs_runner.max_id]
+      gsrun.recheck
+      gs_runner.update
+      #gs_runner.print_out(0)
+      #FileUtils.cp(gsrun.directory + '/ogyropsi.dat', trinity_runner.root_folder + '/.')
 
-      trinity_runner.run_class.instance_variable_set(:@mpi_communicator, MPI::Comm::WORLD)
-      if false and trinity_runner.run_list.size > 0
+      run.gs_folder = gsrun.directory
+      while (
+        not FileTest.exist? run.gs_folder + '/ogyropsi.dat' or
+        File.read(run.gs_folder + '/ogyropsi.dat') =~ /nan/i
+      )
+        #eputs "GS solver failed: using previous solution"
+
+        gs_runner.conditions = 'id == ' + @gsid.to_s
+        gs_runner.destroy(no_confirm: true)
+        gs_runner.conditions = nil
+        eputs "GS solver failed for #{v.inspect}: returning 10000"
+        return [10000, false]
+        #run.gs_folder = gs_runner.run_list[@gsid -= 1].directory
+      end
+      #run.evolve_geometry = ".true."
+      eputs ['Set gs_folder', run.gs_folder]
+      trinity_runner.run_class.instance_variable_set(:@delay_execution, true)
+      if trinity_runner.run_list.size > 0
+        run.restart_id = @id
       else
-        crun = chease_runner.run_class.new(chease_runner)
-        crun.update_submission_parameters(pars[:chease].inspect)
-        if @first_run_done
-          #crun.nppfun=4
-          #crun.neqdsk=0
-          #crun.expeq_file = trinity_runner.run_list[@id]
-        end
-        if chease_runner.run_list.size > 0
-          crun.restart_id = @cid
-        end
-        chease_runner.submit(crun)
-        crun = chease_runner.run_list[@cid = chease_runner.max_id]
-        crun.recheck
-        chease_runner.update
-        #chease_runner.print_out(0)
-        #FileUtils.cp(crun.directory + '/ogyropsi.dat', trinity_runner.root_folder + '/.')
-
-        run = trinity_runner.run_class.new(trinity_runner)
-
-        run.update_submission_parameters(pars[:trinity].inspect)
-        run.gs_folder = crun.directory
-        run.evolve_geometry = ".true."
-        #trinity_runner.run_class.instance_variable_set(:@delay_execution, true)
-        if trinity_runner.run_list.size > 0
-          run.restart_id = @id
-        end
-        trinity_runner.submit(run)
-        run = trinity_runner.run_list[@id = trinity_runner.max_id]
-        run.recheck
-        trinity_runner.update
-        #trinity_runner.print_out(0)
-        result =  run.send(@optimised_quantity)
-        p ['result is ', result]
-        @first_run_done = true
-        return -result
       end
+      eputs 'Submitting run'
+      run.wall_mins = remaining_wall_mins
+      trinity_runner.submit(run)
+      run = trinity_runner.run_list[@id = trinity_runner.max_id]
 
 
-      #v.square.sum
+      comm = MPI::Comm::WORLD
+      arr = NArray.int(1)
+      arr[0] = 1
+      eputs 'Sending message'
+      comm.Bcast(arr,0)
+      comm.Bcast_string(run.directory)
+      comm.Bcast_string(run.run_name)
+      eputs 'Running trinity'
+      Dir.chdir(run.directory){run.run_trinity(run.run_name+'.trin', comm)}
+      eputs 'Rechecking'
+      trinity_runner.update
+      eputs 'Queue', run.queue_status
+
+      trinity_runner.update
+      @first_trinity_run_completed
+    end # if not @replay
+    #trinity_runner.print_out(0)
+    Dir.chdir(run.directory) do
+      run.recheck
+      run.status = :Complete
+      run.get_global_results
+      if (run.evolve_geometry and run.evolve_geometry.fortran_true?)
+        repeat = false
+      else
+        repeat = true
+      end
+    end
+    result =  run.instance_eval(@optimised_quantity)
+    p ['result is ', result, 'repeat: ', repeat]
+    @first_run_done = true
+    @results_hash[:func_calls] ||=[]
+    @results_hash[:func_calls].push [print_pars, result]
+    Hash.phoenix('func_calls.rb') do |hash|
+      hash[@id] ||={}
+      hash[@id][:result] = result
+      hash[@id][:repeat] = repeat
+      hash[@id][:is_converged] = run.is_converged?
+      hash
     end
+    return [-result, repeat, run.is_converged?]
+    #end
+
+
+    #v.square.sum
+  end
 end

data/lib/trinoptcrmod/trinopt.rb

@@ -1,9 +1,12 @@
-
+require 'mpi'
 class CodeRunner
 	#  This is a customised subclass of the CodeRunner::Run  class  which is designed to run the CodeRunner/Trinity optimisation framework
 	#
+  CodeRunner.setup_run_class('trinity')
+  CodeRunner.setup_run_class('chease')
 	class Trinopt < Run
 
+
 		# Where this file is
 		@code_module_folder = File.dirname(File.expand_path(__FILE__)) # i.e. the directory this file is in
 
@@ -18,16 +21,56 @@ class CodeRunner
 
 		@code_long="CodeRunner/Trinity Optimisation Framework"
 
-		@run_info=[:time, :is_a_restart, :restart_id, :restart_run_name, :completed_steps, :percent_complete]
+		@run_info=[:time, :is_a_restart, :restart_id, :restart_run_name, :completed_steps, :percent_complete, :start_time]
 
     @variables = [
       :chease_exec,
+      :ecom_exec,
       :output,
       :search,
       :trinity_defaults,
+      :trinity_defaults_strings,
       :gs_defaults,
-      :nit
+      :chease_defaults_strings,
+      :ecom_defaults_strings,
+      :nit,
+      :ntstep_first,
+      :ntstep,
+      :delete_final_run, 
+      :trinity_pars,
+      :chease_pars,
+      :ecom_pars,
+      :gs_code,
+      :convergence,
+      :max_func_evals,
+      :use_previous_pressure,
+      :use_ifspppl_first,
+      :wall_mins_margin
     ]
+    def gs_defaults_strings
+      case @gs_code
+      when 'chease'
+        @chease_defaults_strings ||= @gs_defaults_strings # For backwards compatibility
+      else
+        @ecom_defaults_strings
+      end
+    end
+    def gs_defaults_strings=(strs)
+      @chease_defaults_strings = strs
+    end
+    def gs_pars
+      case @gs_code
+      when 'chease'
+        @chease_pars ||= @gs_pars
+      when 'ecom'
+        @gs_pars
+      end
+    end
+
+    # For backwards compatibility
+    def gs_pars=(pars)
+      @chease_pars = pars
+    end
 
 		@uses_mpi = true
 
@@ -36,7 +79,32 @@ class CodeRunner
 		@naming_pars = []
 
 		#  Any folders which are a number will contain the results from flux simulations.
-		@excluded_sub_folders = ['trinity_runs', 'chease_runs', 'ecom_runs']
+		@excluded_sub_folders = ['trinity_runs', 'gs_runs']
+
+    def initialize(*args)
+      @trinity_defaults_strings = []
+      @chease_defaults_strings = []
+      @ecom_defaults_strings = []
+      @convergence = 0.05
+      @max_func_evals = 4
+      @wall_mins_margin = 5.0
+      @wall_mins = 1.0e10
+      super(*args)
+    end
+		def evaluate_defaults_file(filename)
+			text = File.read(filename)
+			instance_eval(text)
+			text.scan(/^\s*@(\w+)/) do
+				var_name = $~[1].to_sym
+				next if var_name == :defaults_file_description
+				next if var_name == :code_run_environment
+				unless rcp.variables.include? var_name or (CodeRunner::Trinity.rcp.variables.include? var_name) or (CodeRunner::Chease.rcp.variables.include? var_name or CodeRunner::Gryfx.rcp.variables.include? var_name or CodeRunner::Gs2.rcp.variables.include? var_name or CodeRunner::Ecom.rcp.variables.include? var_name)
+					warning("---#{var_name}---, specified in #{File.expand_path(filename)}, is not a variable. This could be an error")
+				end
+			end
+      eputs '@nstep_is', @nstep
+      eputs '@nstep_first', @nstep_first
+		end
 
 		#  A hook which gets called when printing the standard run information to the screen using the status command.
 		def print_out_line
@@ -64,63 +132,133 @@ class CodeRunner
 			new_run.is_a_restart = true
 			new_run.restart_id = @id
 			new_run.restart_run_name = @run_name
-			new_run.nopt = -1
 			new_run.run_name = nil
 			new_run.naming_pars = @naming_pars
 			new_run.update_submission_parameters(new_run.parameter_hash.inspect, false) if new_run.parameter_hash 
+      new_run.trinity_pars = @trinity_pars.absorb(new_run.trinity_pars) if @trinity_pars and new_run.trinity_pars
 			new_run.naming_pars.delete(:restart_id)
 			new_run.generate_run_name
-      raise "This function is not complete"
+      raise "trinity_runs directory already exists" if FileTest.exist? new_run.directory + '/trinity_runs'
+      FileUtils.ln_s(@directory + '/trinity_runs', new_run.directory + '/trinity_runs')
+      FileUtils.ln_s(@directory + '/gs_runs', new_run.directory + '/gs_runs')
 		end	
 		#  This is a hook which gets called just before submitting a simulation. It sets up the folder and generates any necessary input files.
 		def generate_input_file
 				check_parameters
 				if @restart_id
 					@runner.run_list[@restart_id].restart(self)
+        else
+          FileUtils.makedirs('trinity_runs')
+          FileUtils.makedirs('gs_runs')
 				end
         File.open("driver_script.rb", "w"){|f| f.puts optimisation_script}
-        FileUtils.makedirs('trinity_runs')
-        FileUtils.makedirs('gs_runs')
-        FileUtils.ln_s("../../#{@trinity_defaults}_defaults.rb", "trinity_runs")
-        FileUtils.ln_s("../../#{@gs_defaults}_defaults.rb", "gs_runs")
+        #FileUtils.ln_s("../../#{@trinity_defaults}_defaults.rb", "trinity_runs")
+        #FileUtils.ln_s("../../#{@gs_defaults}_defaults.rb", "gs_runs")
         save
 		end
 
     def optimisation_script
       return <<EOF
-      require 'coderunner'
-      CodeRunner.setup_run_class('trinity')
-      CodeRunner.setup_run_class('trinopt')
-      require 'trinitycrdriver'
-      require 'trinitycrdriver/optimisation'
-      CodeRunner::Trinopt.run_optimisation(#@id)
+      require 'mpi'
+      class MPI::Comm
+        def Bcast_string(str)
+          @arr = NArray.int(1)
+          if rank==0
+            @arr[0] = str.length
+            Bcast(@arr, 0)
+            Bcast(str, 0)
+          else
+            Bcast(@arr,0)
+            str << " " while str.length < @arr[0]
+            Bcast(str,0)
+          end
+        end
+      end
+      puts 'Initializing mpi'
+		  MPI.Init
+      comm = MPI::Comm::WORLD
+      rank = comm.rank
+      puts ['Rank is: ', rank]
+      if rank==0
+        begin
+          require 'coderunner'
+          CodeRunner.setup_run_class('trinity')
+          CodeRunner.setup_run_class('trinopt')
+          require 'trinitycrdriver'
+          require 'trinitycrdriver/optimisation'
+          CodeRunner::Trinopt.run_optimisation(#@id)
+        rescue =>err
+          arr = NArray.int(1)
+          arr[0] = 0
+          comm.Bcast(arr,0)
+          raise err
+        end
+        arr = NArray.int(1)
+        arr[0] = 0
+        comm.Bcast(arr,0)
+      else
+        require 'trinitycrdriver'
+        arr = NArray.int(1)
+        puts "Proc \#{comm.rank} waiting for message"
+        loop do
+          comm.Bcast(arr, 0)
+          puts "Proc \#{comm.rank} received instructions: \#{arr[0]}"
+          dir = ""
+          run_name  = ""
+          if arr[0] == 1
+            comm.Bcast_string(dir)
+            comm.Bcast_string(run_name)
+            puts "Proc \#{comm.rank} calling Trinity with run_name: \#{run_name}"
+            Dir.chdir(dir){CodeRunner::Trinity.new.run_trinity(run_name+'.trin', comm)}
+          else
+            break
+          end
+        end
+      end
+      MPI.Finalize
 EOF
     end
 
 		def check_parameters
+      if delete_final_run
+        raise CRFatal.new("Cancelled submission") unless Feedback.get_boolean("You have set delete_final_run which will cause the final run to be deleted. Is this correct?")
+      end
 		end
 
 
     def self.run_optimisation(id = ARGV[-1])
-		  MPI.Init
-      @runner = CodeRunner.fetch_runner(Y: '../../', U: true)
-      #@run = @runner.run_list[id.to_i]
-      @run = self.load(Dir.pwd, @runner)
-      #raise "Can't find run with id #{id}; #{@runner.run_list.keys}" unless @run
-      opt = CodeRunner::Trinity::Optimisation.new(
-        @run.output, @run.search
-      )
-      @trinity_runner = CodeRunner.fetch_runner(Y: 'trinity_runs', X: '/dev/null', C: 'trinity', D: @run.trinity_defaults)
-      @trinity_runner.nprocs = MPI::Comm::WORLD.size
-      @chease_runner = CodeRunner.fetch_runner(Y: 'gs_runs', X: @run.chease_exec, C: 'chease', D: @run.gs_defaults)
-      @chease_runner.nprocs = '1'
-      #Dir.chdir('trinity_runs'){@trinity_runner.run_class.use_new_defaults_file('rake_test_opt', 'ifspppl_chease_input.trin')}
-      #Dir.chdir(tfolderchease){@chease_runner.run_class.use_new_defaults_file('rake_test_opt_chease', 'chease_example.in')}
-      #assert_equal([:trinity, :powerin], opt.optimisation_variables[0])
-      opt.trinity_runner = @trinity_runner
-      opt.chease_runner = @chease_runner
-      opt.serial_optimise(:simplex, @run)
-      MPI.Finalize
+        eputs 'Fetching runner'
+        runner = CodeRunner.fetch_runner(Y: '../../', U: true)
+        eputs 'Got runner'
+        #@run = @runner.run_list[id.to_i]
+        #run = self.load(Dir.pwd, runner)
+        run = self.new(runner)
+        run.read_info
+        run.start_time = Time.now.to_i
+        eputs 'Loaded run'
+        #ep @run
+        #raise "Can't find run with id #{id}; #{@runner.run_list.keys}" unless @run
+        opt = CodeRunner::Trinity::Optimisation.new(
+          run.output, run.search
+        )
+        eputs 'Created opt'
+        trinity_runner = CodeRunner.fetch_runner(Y: 'trinity_runs', X: '/dev/null', C: 'trinity')
+        trinity_runner.nprocs = MPI::Comm::WORLD.size
+        eputs 'Got trinity runner'
+        case run.gs_code
+        when 'chease'
+          gs_runner = CodeRunner.fetch_runner(Y: 'gs_runs', X: run.chease_exec, C: 'chease')
+          gs_runner.nprocs = '1'
+        when 'ecom'
+          gs_runner = CodeRunner.fetch_runner(Y: 'gs_runs', X: run.ecom_exec, C: 'ecom')
+          gs_runner.nprocs = '1'
+        else
+          raise "Unknown gs_code #{run.gs_code.inspect}"
+        end
+        eputs 'Got gs runner'
+        opt.trinity_runner = trinity_runner
+        opt.gs_runner = gs_runner
+        opt.serial_optimise(:simplex, run)
     end
 
 
@@ -169,6 +307,60 @@ EOF
 			''
 		end
 
+    def graphkit(name, options)
+      results = eval(File.read(@directory + '/results'))
+      case name
+      when 'evolution'
+        data = {}
+        pars_already_listed = []
+        results[:func_calls].reverse.each do |pars, res|
+          next if pars_already_listed.include? pars
+          pars_already_listed.push pars
+          pars.each do |code,cpars|
+            cpars.each do |vname, val|
+              label = "#{code}_#{vname}"
+              data[label] ||= []
+              data[label].push val
+            end
+          end
+          data['results']||=[]
+          data['results'].push res
+        end
+        kit = GraphKit.quick_create(data.values)
+        data.keys.zip(GraphKit::AXES).each{|lbl,ax| kit.set(ax + :label, lbl)}
+        kit
+      when 'iteration'
+        require 'tokfile/ogyropsi'
+        step = options[:step_index]
+        raise "Please specify step_index" unless step
+        iter, _trinstep = trinrunstep(step)[0]
+          kit = TokFile::Ogyropsi.new("#@directory/trinity_runs/v/id_#{iter}/chease/ogyropsi#{sprintf("%05d", step)}.dat").summary_graphkit
+          kit.gp.multiplot = " layout 3,3 title 'Iteration: #{iter}; Step: #{step}; Pars: #{results[:func_calls][iter-1][0]}; Result: #{results[:func_calls][iter-1][1].inspect}'"
+          kit[-1].gp.size = "ratio 1"
+          #pp 'kit', kit
+        return kit
+      end
+    end
+
+    def trinstep_mappings
+      @trinstep_mappings = (
+        trinity_runner = CodeRunner.fetch_runner(Y: @directory + '/trinity_runs')
+        sizes = trinity_runner.run_list.values.sort_by{|r| r.id}.map{|r| r.get_completed_timesteps; r.completed_timesteps}
+        i = 0; cs = 0
+        sizes.inject({}){|h,sz| cs+=sz; h[i+=1]=cs; h}
+      )
+    end
+
+    def trinrunstep(overall_step)
+      p 'trinstep_mappings', trinstep_mappings
+      trinrun, cusum = trinstep_mappings.to_a.find{|t, c| c>=overall_step}
+      [trinrun, cusum-overall_step + 1]
+    end
+
+    def max_step
+      trinstep_mappings[-1][1]
+    end
+
 	end
 end
 

data/trinitycrdriver.gemspec

@@ -2,17 +2,17 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: trinitycrdriver 0.1.1 ruby lib
+# stub: trinitycrdriver 0.1.2 ruby lib
 # stub: ext/trinitycrdriver/extconf.rb
 
 Gem::Specification.new do |s|
   s.name = "trinitycrdriver"
-  s.version = "0.1.1"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Edmund Highcock"]
-  s.date = "2015-07-28"
+  s.date = "2016-06-06"
   s.description = "A gem to allow coderunner to run the trinity code directly."
   s.email = "edmundhighcock@users.sourceforge.net"
   s.extensions = ["ext/trinitycrdriver/extconf.rb"]
@@ -38,7 +38,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/edmundhighcock/trinitycrdriver"
   s.licenses = ["GPLv3"]
-  s.rubygems_version = "2.4.8"
+  s.rubygems_version = "2.2.0"
   s.summary = "A gem to allow coderunner to run the trinity code directly via a C interface."
 
   if s.respond_to? :specification_version then
@@ -48,9 +48,10 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<coderunner>, [">= 0.14.2"])
       s.add_runtime_dependency(%q<text-data-tools>, [">= 1.1.3"])
       s.add_runtime_dependency(%q<gs2crmod>, [">= 0.11.33"])
-      s.add_runtime_dependency(%q<trinitycrmod>, [">= 0.4.7"])
+      s.add_runtime_dependency(%q<trinitycrmod>, [">= 0.7.11"])
       s.add_runtime_dependency(%q<ruby-mpi>, [">= 0.2.0"])
       s.add_runtime_dependency(%q<cheasecrmod>, [">= 0.1.0"])
+      s.add_runtime_dependency(%q<tokfile>, [">= 0.0.3"])
       s.add_development_dependency(%q<shoulda>, ["= 3.0.1"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_development_dependency(%q<bundler>, ["> 1.0.0"])
@@ -62,9 +63,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<coderunner>, [">= 0.14.2"])
       s.add_dependency(%q<text-data-tools>, [">= 1.1.3"])
       s.add_dependency(%q<gs2crmod>, [">= 0.11.33"])
-      s.add_dependency(%q<trinitycrmod>, [">= 0.4.7"])
+      s.add_dependency(%q<trinitycrmod>, [">= 0.7.11"])
       s.add_dependency(%q<ruby-mpi>, [">= 0.2.0"])
       s.add_dependency(%q<cheasecrmod>, [">= 0.1.0"])
+      s.add_dependency(%q<tokfile>, [">= 0.0.3"])
       s.add_dependency(%q<shoulda>, ["= 3.0.1"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_dependency(%q<bundler>, ["> 1.0.0"])
@@ -77,9 +79,10 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<coderunner>, [">= 0.14.2"])
     s.add_dependency(%q<text-data-tools>, [">= 1.1.3"])
     s.add_dependency(%q<gs2crmod>, [">= 0.11.33"])
-    s.add_dependency(%q<trinitycrmod>, [">= 0.4.7"])
+    s.add_dependency(%q<trinitycrmod>, [">= 0.7.11"])
     s.add_dependency(%q<ruby-mpi>, [">= 0.2.0"])
     s.add_dependency(%q<cheasecrmod>, [">= 0.1.0"])
+    s.add_dependency(%q<tokfile>, [">= 0.0.3"])
     s.add_dependency(%q<shoulda>, ["= 3.0.1"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])
     s.add_dependency(%q<bundler>, ["> 1.0.0"])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trinitycrdriver
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Edmund Highcock
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-28 00:00:00.000000000 Z
+date: 2016-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coderunner
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.7
+        version: 0.7.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.7
+        version: 0.7.11
 - !ruby/object:Gem::Dependency
   name: ruby-mpi
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: tokfile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
@@ -235,7 +249,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A gem to allow coderunner to run the trinity code directly via a C interface.