RubyGems - trinitycrdriver - Versions diffs - 0.1.1 → 0.1.2 - Mend

trinitycrdriver 0.1.1 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

checksums.yaml +4 -4
data/Gemfile +2 -1
data/VERSION +1 -1
data/lib/trinitycrdriver.rb +14 -2
data/lib/trinitycrdriver/optimisation.rb +316 -83
data/lib/trinoptcrmod/trinopt.rb +227 -35
data/trinitycrdriver.gemspec +10 -7
metadata +19 -5

checksums.yaml CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

data/lib/trinitycrdriver.rb CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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.