corfucrmod 1.0.0

data/lib/corfucrmod/optimisation.rb

@@ -0,0 +1,352 @@
+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::Corfu::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
+  # 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 :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
+
+    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
+    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
+    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
+        @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)
+
+      # 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 + '/.')
+
+      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
+        if (old_run = trinity_runner.run_list[@id]).is_converged?
+          eputs "Previous trinity run #@id converged: using profile as initial condition"
+          run.init_option="trinity"
+          ## We have to copy the file because we need to be able to access the original from R
+          #FileUtils.cp("../id_#@id/#{old_run.run_name}.out.nc", "../id_#@id/#{old_run.run_name}_copy.out.nc")
+          run.init_file = "../id_#@id/#{old_run.run_name}.out.nc"
+          run.init_time = old_run.new_netcdf_file.var("t").get[-1]
+          old_run.new_ncclose rescue nil # Make sure the file is closed
+        else
+          eputs "Previous trinity run #@id not converged: restarting"
+          run.restart_id = @id
+        end 
+      end
+      eputs 'Submitting run'
+      run.wall_mins = remaining_wall_mins
+      trinity_runner.submit(run)
+      run = trinity_runner.run_list[@id = trinity_runner.max_id]
+
+
+      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/corfucrmod/trinitycrdriver.rb

@@ -0,0 +1,61 @@
+require 'ffi'
+class CodeRunner
+  class Trinity
+    module TrinityDriver                                                                         
+      extend FFI::Library                                                                        
+      ffi_lib ENV['TRINITY'] + '/libtrin.so'                                                     
+      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',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
+require 'corfucrmod/trinitycrdriver_ext'
+require 'mpi'
+
+class CodeRunner::Trinity
+	# We overwrite the system module's implemenation of this command.
+	# 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
+		end
+	end
+	def execute_actual
+		Dir.chdir(@directory){
+			if rcp.mpi_communicator?
+				start_mpi = false
+				mpicomm = rcp.mpi_communicator
+			else
+				start_mpi = true
+				MPI.Init
+				mpicomm = MPI::Comm::WORLD
+				puts ["INITIALISED MPI", mpicomm.size ]
+			end
+			run_trinity(@run_name + ".trin", mpicomm)
+			if start_mpi
+				MPI.Finalize
+			end
+
+		}
+	end
+end

metadata

@@ -0,0 +1,261 @@
+--- !ruby/object:Gem::Specification
+name: corfucrmod
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Edmund Highcock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: coderunner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+- !ruby/object:Gem::Dependency
+  name: text-data-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+- !ruby/object:Gem::Dependency
+  name: gs2crmod
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.33
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.33
+- !ruby/object:Gem::Dependency
+  name: trinitycrmod
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.11
+- !ruby/object:Gem::Dependency
+  name: ruby-mpi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: cheasecrmod
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  CorFu, the Coderunner/Trinity Fusion Optimisation Framework
+      allows the optimisation of fusion performance using first principles
+      flux calculations via Trinity.
+email: edmundhighcock@users.sourceforge.net
+executables: []
+extensions:
+- ext/corfucrmod/extconf.rb
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+- README.rdoc.orig
+files:
+- ".document"
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- README.rdoc.orig
+- Rakefile
+- VERSION
+- clean.sh
+- corfucrmod.gemspec
+- ext/corfucrmod/extconf.rb
+- ext/corfucrmod/trinitycrdriver_ext.c
+- lib/corfucrmod.rb
+- lib/corfucrmod/corfu.rb
+- lib/corfucrmod/optimisation.rb
+- lib/corfucrmod/trinitycrdriver.rb
+homepage: http://github.com/edmundhighcock/corfucrmod
+licenses:
+- GPLv3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: A gem which implements the CorFu Optimisation Framework.
+test_files: []