trinitycrmod 0.6.9 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70d5de67c1071d586f98ace5987cd0fbde2f77f5
-  data.tar.gz: 280ed4b4c41a8d0cd286aee3ef84743d8675aa4e
+  metadata.gz: 3fb8ea31bb4ef23998f583fb453df5ea05eb16ac
+  data.tar.gz: dd0e0d6b0f9bc15b43e61cbb7373bff07780db05
 SHA512:
-  metadata.gz: 77b3ce0fda8680f9d8397c49be4ffae800932a1daaa83b5d223e33630e72b116a0071c17f046f1bbb0f289c8094580646e68b6d2c39bba7fe61e26a8eff3a6b1
-  data.tar.gz: 32f14d8439eba8441d32d5b0e06d983d464a533971955b419e4a940cb4def247afa0b25ae14fc8d232a814c129d175ae77e1c4bdbcf80a9afa9b886088024cb2
+  metadata.gz: 4cfbe86b9003759c94e641305cb65b2e516600412bdc7731aa60e939a41d80bce2b6b13d110b6f812af76648424dd3a77da1ec8603c8a15ede0adf9cc15b7f69
+  data.tar.gz: c765d21c28840c38c38cfff5c3e2102fe371f77890834f8dfd254f1c55eb9dad72dfa50ee3456eecbed45b9f3d790aebdaff92f5999a050fd8c7a01f25afb444

data/Gemfile

@@ -1,20 +1,19 @@
 source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
-   gem "coderunner", ">= 0.15.5"
-   gem "text-data-tools", ">= 1.1.3"
+   gem "coderunner", ">= 0.16.10"
+   gem "text-data-tools", ">= 1.1.6"
 	 gem "gs2crmod", ">=0.11.76"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  #gem "shoulda", ">= 0"
+  gem "shoulda", ">= 0"
   #gem "rdoc", "~> 3.12"
   #gem "bundler", "> 1.0.0"
   #gem "jeweler", ">= 2.0.0"
-  gem "shoulda", " 3.0.1"
+  #gem "shoulda", " 3.0.1"
   gem "rdoc", "~> 3.12"
   gem "bundler", "> 1.0.0"
-  gem "jeweler", ">= 1.8.4"
-	gem "minitest", "~> 4"
+  gem "jeweler", ">= 2.00"
 end

data/VERSION

@@ -1 +1 @@
-0.6.9
+0.7.0

data/lib/trinitycrmod/flux_interpolator.rb

@@ -0,0 +1,208 @@
+require 'scanf'
+class CodeRunner
+class ZeroEval
+  def eval(*args)
+    0.0
+  end
+end
+class Trinity
+class << self
+  # To be used in conjunction with the shell script
+  # option in Trinity. Read the output of old_run_name
+  # (which may be a commma-separated list of multiple runs)
+  # and read the contents of <run_name>_flux_inputs.dat and use them
+  # to interpolate esitmates of the fluxes
+  def interpolate_fluxes(old_run_folder, run_folder, grad_option, ntspec)
+    old_run_name = nil
+    Dir.chdir(old_run_folder) do
+      old_cc = Dir.entries(Dir.pwd).find{|f| f =~ /\.cc$/}
+      raise "Can't find cc file in #{old_run_folder}" unless old_cc
+      old_run_name = File.expand_path(old_cc).sub(/.cc$/,'')
+    end
+
+    run_name = nil
+    Dir.chdir(run_folder) do
+      new_inp = Dir.entries(Dir.pwd).find{|f| f =~ /.flux_inputs$/}
+      raise "Can't find flux_inputs in #{run_folder}" unless new_inp
+      run_name = File.expand_path(new_inp).sub(/.flux_inputs$/,'')
+    end
+    
+
+    ccfile = TextDataTools::Column::DataFile.new(old_run_name + '.cc', true, /\S+/, /(?:\#\s+)?\d+:.*?(?=\d+:|\Z)/)
+    geofile = TextDataTools::Column::DataFile.new(old_run_name + '.geo', true, /\S+/, /(?:\#\s+)?\d+:\D*?(?=\d:|\d\d:|\Z)/)
+    radius_data = ccfile.get_1d_array_float(/radius/)
+    radius_uniq = radius_data.uniq
+    p 'radius_uniq', radius_uniq
+    ncc = radius_uniq.size
+    np = radius_data.size/ncc
+    p 'np is ', np, 'ncc is', ncc
+    #p 'ion_tprim_perturb_data',ion_tprim_perturb_data = ccfile.get_1d_array_float(/11:/).pieces(np)
+    perturb = {
+      fprim: /10:/,
+      ion_tprim: /11:/,
+      eln_tprim: /12:/,
+      dens: /18:/,
+      ion_temp: /19:/,
+      eln_temp: /20:/
+    }
+    perturb_data = perturb.inject({}) do |h,(k,v)| 
+      begin
+        h[k] = ccfile.get_1d_array_float(v).pieces(np).transpose
+      rescue=>err
+        p ccfile.get_1d_array(v)
+        puts "Error reading: #{k}, #{v}"
+        raise err
+      end
+      h
+    end
+    fluxes = {
+      ion_hflux: /5: i/,
+      eln_hflux: /6: e/,
+      pflux: /3: i/,
+      lflux: /9: v/,
+      ion_heat: /7: i/,
+      eln_heat: /8: e/
+    }
+    fluxes_data = fluxes.inject({}) do |h,(k,v)| 
+      h[k] = ccfile.get_1d_array_float(v).pieces(np).transpose
+      h
+    end
+    area = geofile.get_1d_array_float(/area/)
+    grho = geofile.get_1d_array_float(/grho/)
+    case grad_option
+    when 'tigrad'
+      jacobian_vecs = [:ion_temp,:ion_tprim]
+      jacobian_vecs = [:ion_tprim]
+      interp_vecs = [:ion_hflux]
+      njac = 2
+    when 'ntgrads'
+      jacobian_vecs = [:ion_tprim, :eln_tprim, :fprim]
+      jacobian_vecs = [:ion_tprim, :fprim]
+      interp_vecs = [:ion_hflux, :eln_hflux, :pflux]
+      njac = 4
+    else 
+      raise "Unknown grad_option: #{grad_option}"
+    end
+    GraphKit.quick_create([perturb_data[:ion_tprim][0].to_gslv, fluxes_data[:ion_hflux][0].to_gslv])#.gnuplot
+    #p perturb_data[:ion_tprim][0]
+    interp = fluxes_data.inject({}) do |h, (k,v)|
+        h[k] = radius_uniq.size.times.map do |i| 
+          if interp_vecs.include?(k)
+            #puts 'i is', i
+            GSL::ScatterInterp.alloc(
+              :linear, 
+              jacobian_vecs.map{|name| 
+                arr = perturb_data[name]
+                arr[i].to_gslv + 
+                GSL::Vector.linspace(0,1e-9,arr[i].size)
+              } + [v[i].to_gslv], 
+              false,
+             1.0
+            ) 
+          else
+            ZeroEval.new
+          end
+        end
+      h
+    end
+    if false and run_name != 'dummy'
+      arr = []
+      File.read(run_name + '.flux_inputs').scanf("%e"){|m| p m; arr+= m}
+      # each of these quantities is a flat array with 
+      # radial index varying fastest, then jacobian index
+      # then species index where appropriate
+      i = 0
+      #p arr
+      dens = arr[i...(i+=ncc*njac)]
+      temp = arr[i...(i+=ncc*njac*2)].pieces(2) # This is hardwired to 2
+      fprim = arr[i...(i+=ncc*njac)]
+      tprim = arr[i...(i+=ncc*njac*2)].pieces(2) # This is hardwired to 2
+      inputs = {}
+      inputs[:dens] = dens
+      inputs[:ion_temp] = temp[0]
+      inputs[:eln_temp] = temp[1]
+      inputs[:fprim] = fprim
+      inputs[:ion_tprim] = tprim[0]
+      inputs[:eln_tprim] = tprim[1]
+
+      #p 'inputs', inputs.values.map{|v| v.size}, inputs[:eln_tprim]
+
+      File.open(run_name + '.flux_results', 'w') do |file|
+        njac.times{|ij| (ntspec+1).times{ ncc.times{|ic| file.printf("%e ",interp[:pflux][ic].eval(*jacobian_vecs.map{|v| inputs[v][ic + ij*ncc]}))}}}
+        file.printf("\n")
+        njac.times{|ij| 
+          ncc.times{|ic| file.printf("%e ",interp[:ion_hflux][ic].eval(*jacobian_vecs.map{|v| inputs[v][ic + ij*ncc]}))}
+          ntspec.times{
+            ncc.times{|ic| file.printf("%e ",interp[:eln_hflux][ic].eval(*jacobian_vecs.map{|v| inputs[v][ic + ij*ncc]}))}
+          }
+        }
+        file.printf("\n")
+        njac.times{|ij| 
+          ncc.times{|ic| file.printf("%e ",interp[:ion_heat][ic].eval(*jacobian_vecs.map{|v| inputs[v][ic + ij*ncc]}))}
+          ntspec.times{
+            ncc.times{|ic| file.printf("%e ",interp[:eln_heat][ic].eval(*jacobian_vecs.map{|v| inputs[v][ic + ij*ncc]}))}
+          }
+        }
+        file.printf("\n")
+        njac.times{|ij| ncc.times{|ic| file.printf("%e ",interp[:lflux][ic].eval(*jacobian_vecs.map{|v| inputs[v][ic + ij*ncc]}))}}
+        file.printf("\n")
+        area.each{|v| file.printf("%e ", v)}
+        file.printf("\n")
+        grho.each{|v| file.printf("%e ", v)}
+        file.printf("\n")
+      end
+    else
+      vec = GSL::Vector.linspace(perturb_data[:ion_tprim][0].min, perturb_data[:ion_tprim][0].max,20)
+      vec2 = GSL::Vector.linspace(perturb_data[:fprim][0].min, perturb_data[:fprim][0].max,20)
+      mat = GSL::Matrix.alloc(20,20)
+      for i in 0...20
+        for j in 0...20
+          mat[i,j] = interp[:ion_hflux][0].eval(vec[i], vec2[j])
+        end
+      end
+      vec3 = GSL::Vector.linspace(perturb_data[:ion_tprim][1].min, perturb_data[:ion_tprim][1].max,20)
+      vec4 = GSL::Vector.linspace(perturb_data[:fprim][1].min, perturb_data[:fprim][1].max,20)
+      mat2 = GSL::Matrix.alloc(20,20)
+      for i in 0...20
+        for j in 0...20
+          mat2[i,j] = interp[:ion_hflux][1].eval(vec3[i], vec4[j])
+        end
+      end
+      #vec.collect{|x| vec2.collect{|y| mat(interp[:ion_hflux][0].eval(x)}
+      #GraphKit.quick_create([vec, vec2, mat], [perturb_data[:ion_tprim][0].to_gslv, perturb_data[:fprim][0], fluxes_data[:ion_hflux][0].to_gslv], [vec3, vec4, mat2], [perturb_data[:ion_tprim][1].to_gslv, perturb_data[:fprim][1], fluxes_data[:ion_hflux][1].to_gslv]).gnuplot live: true
+      vec5 = GSL::Vector.linspace(perturb_data[:ion_tprim][2].min, perturb_data[:ion_tprim][2].max,20)
+      vec6 = GSL::Vector.linspace(perturb_data[:fprim][2].min, perturb_data[:fprim][2].max,20)
+      mat3 = GSL::Matrix.alloc(20,20)
+      for i in 0...20
+        for j in 0...20
+          mat3[i,j] = interp[:ion_hflux][2].eval(vec5[i], vec6[j])
+        end
+      end
+      #vec.collect{|x| vec2.collect{|y| mat(interp[:ion_hflux][0].eval(x)}
+      #GraphKit.quick_create([vec, vec2, mat], [perturb_data[:ion_tprim][0].to_gslv, perturb_data[:fprim][0], fluxes_data[:ion_hflux][0].to_gslv], [vec3, vec4, mat2], [perturb_data[:ion_tprim][1].to_gslv, perturb_data[:fprim][1], fluxes_data[:ion_hflux][1].to_gslv],[vec5, vec6, mat3], [perturb_data[:ion_tprim][2].to_gslv, perturb_data[:fprim][2], fluxes_data[:ion_hflux][2].to_gslv]).gnuplot live: true
+      vec7 = GSL::Vector.linspace(perturb_data[:ion_tprim][3].min, perturb_data[:ion_tprim][3].max,20)
+      vec8 = GSL::Vector.linspace(perturb_data[:fprim][3].min, perturb_data[:fprim][3].max,20)
+      mat4 = GSL::Matrix.alloc(20,20)
+      for i in 0...20
+        for j in 0...20
+          mat4[i,j] = interp[:ion_hflux][3].eval(vec7[i], vec8[j])
+        end
+      end
+      #vec.collect{|x| vec2.collect{|y| mat(interp[:ion_hflux][0].eval(x)}
+      GraphKit.quick_create([vec, vec2, mat], [perturb_data[:ion_tprim][0].to_gslv, perturb_data[:fprim][0], fluxes_data[:ion_hflux][0].to_gslv], [vec3, vec4, mat2], [perturb_data[:ion_tprim][1].to_gslv, perturb_data[:fprim][1], fluxes_data[:ion_hflux][1].to_gslv],[vec5, vec6, mat3], [perturb_data[:ion_tprim][2].to_gslv, perturb_data[:fprim][2], fluxes_data[:ion_hflux][2].to_gslv],[vec7, vec8, mat4], [perturb_data[:ion_tprim][3].to_gslv, perturb_data[:fprim][3], fluxes_data[:ion_hflux][3].to_gslv]).gnuplot live: true
+    end
+      #vec = GSL::Vector.linspace(perturb_data[:ion_tprim][0].min, perturb_data[:ion_tprim][0].max,20)
+      #GraphKit.quick_create([vec, vec.collect{|x| interp[:ion_hflux][0].eval(x)}], [perturb_data[:ion_tprim][0].to_gslv, fluxes_data[:ion_hflux][0].to_gslv]).gnuplot
+
+      #vec = GSL::Vector.linspace(perturb_data[:ion_tprim][1].min, perturb_data[:ion_tprim][1].max,20)
+      #GraphKit.quick_create([vec, vec.collect{|x| interp[:ion_hflux][1].eval(x)}], [perturb_data[:ion_tprim][1].to_gslv, fluxes_data[:ion_hflux][1].to_gslv]).gnuplot
+      #vec = GSL::Vector.linspace(perturb_data[:ion_tprim][2].min, perturb_data[:ion_tprim][2].max,80)
+      #GraphKit.quick_create([vec, vec.collect{|x| interp[:ion_hflux][2].eval(x)}], [perturb_data[:ion_tprim][2].to_gslv, fluxes_data[:ion_hflux][2].to_gslv]).gnuplot
+      #STDIN.gets
+    #GraphKit.quick_create([vec, vec.collect{|x| interp[:ion_hflux][0].eval(perturb_data[:ion_tprim][0].to_gslv.min, x)}]).gnuplot
+
+    #p [tprim_perturb_data, fprim_perturb_data]
+  end
+end
+end
+end

data/lib/trinitycrmod/graphs.rb

@@ -1,97 +1,97 @@
 class CodeRunner::Trinity
-	module TrinityGraphKits
-		# Graphs plotting quantities from the '.nt' file vs rho for a given t_index
-		def nt_prof_graphkit(options)
-			prof_graphkit(options.dup.absorb({outfile: :nt}))
-		end
-		# Graphs plotting quantities from the '.nt' file vs rho for a given t_index
-		def pwr_prof_graphkit(options)
-			prof_graphkit(options.dup.absorb({outfile: :pwr, radius_match: /2.*rad/}))
-		end
-		# Graphs plotting quantities from the '.fluxes' file vs rho for a given t_index
-		def fluxes_prof_graphkit(options)
-			prof_graphkit(options.absorb({outfile: :fluxes, exclude_perturbed_fluxes: true}))
-		end
-		# Graphs plotting quantities from the '.pbalance' file vs rho for a given t_index
-		def pbalance_prof_graphkit(options)
-			prof_graphkit(options.absorb({outfile: :pbalance}))
-		end
-		def prof_graphkit(options)
-			raise "Please specify t_index" unless options[:t_index]
-			it = options[:t_index] - 1
-			if ta  = options[:time_average]
-				if ta < 0
-					t_indices = (it+ta..it).to_a
-				else
-					t_indices = (it..it+ta).to_a
-				end
-			else
-				t_indices = [it]
-			end
-			array = t_indices.map{|i| get_2d_array_float(options[:outfile], options[:header], /1.*time/)[i].to_gslv}.mean.to_a
-			rho_array = t_indices.map{|i| get_2d_array_float(options[:outfile], options[:radius_match]||/2.*radius/, /1.*time/)[i].to_gslv}.mean.to_a
-			if options[:exclude_perturbed_fluxes]
-				#s = array.size
-				array = array.slice(0...nrad-1)
-				rho_array = rho_array.slice(0...nrad-1)
-			end
-			#p rho_array, array
-			kit = GraphKit.autocreate(x: {data: rho_array.to_gslv, title: 'rho', units: ''},
-													y: {data: array.to_gslv, title: options[:title]||"", units: options[:units]||""}
-												 )
-			kit.data[0].title += " at time = #{list(:t)[it+1]} s for id #{id}"
-			kit.data[0].gp.with = 'lp'
-			kit
-		end
-		# Graph of Qi in gyroBohm units against rho for a given t_index
-		def ion_hflux_gb_prof_graphkit(options)
-			fluxes_prof_graphkit(options.absorb({header: /Qi.*\(GB/, title: 'Ion Heat Flux', units: 'Q_gB'}))
-		end
-		# Graph of Qi in MW against rho for a given t_index
-		def ion_hflux_prof_graphkit(options)
-			fluxes_prof_graphkit(options.absorb({header: /Qi.*\(MW/, title: 'Ion Heat Flux', units: 'MW'}))
-		end
-		# Graph of Qe in gyroBohm units against rho for a given t_index
-		def eln_hflux_gb_prof_graphkit(options)
-			fluxes_prof_graphkit(options.absorb({header: /Qe.*\(GB/, title: 'Electron Heat Flux', units: 'Q_gB'}))
-		end
-		# Graph of Qe in MW against rho for a given t_index
-		def eln_hflux_prof_graphkit(options)
-			fluxes_prof_graphkit(options.absorb({header: /Qe.*\(MW/, title: 'Electron Heat Flux', units: 'MW'}))
-		end
-		# Graph of toroidal angular momentum flux in gyroBohm units against rho for a given t_index
-		def lflux_gb_prof_graphkit(options)
-			fluxes_prof_graphkit(options.absorb({header: /Pi.*\(GB/, title: 'Toroidal Angular Momentum Flux', units: 'Pi_gB'}))
-		end
-		# Graph of toroidal angular momentum against rho for a given t_index
-		def ang_mom_prof_graphkit(options)
-			return nt_prof_graphkit(options.absorb({header: /ang\s+mom/, title: 'Angular Momentum', units: ''}))
-		end
-		# Graph of Ti against rho for a given t_index
-		def ion_temp_prof_graphkit(options)
-			return nt_prof_graphkit(options.absorb({header: /i\+ temp/, title: 'Ti', units: 'keV'}))
-		end
-		# Graph of Te against rho for a given t_index
-		def eln_temp_prof_graphkit(options)
-			return nt_prof_graphkit(options.absorb({header: /e\- temp/, title: 'Te', units: 'keV'}))
-		end
-		# Graph of n against rho for a given t_index
-		def dens_prof_graphkit(options)
-			return nt_prof_graphkit(options.absorb({header: /dens/, title: 'n', units: '10^20 m^-3'}))
-		end
+  module TrinityGraphKits
+    # Graphs plotting quantities from the '.nt' file vs rho for a given t_index
+    def nt_prof_graphkit(options)
+      prof_graphkit(options.dup.absorb({outfile: :nt}))
+    end
+    # Graphs plotting quantities from the '.nt' file vs rho for a given t_index
+    def pwr_prof_graphkit(options)
+      prof_graphkit(options.dup.absorb({outfile: :pwr, radius_match: /2.*rad/}))
+    end
+    # Graphs plotting quantities from the '.fluxes' file vs rho for a given t_index
+    def fluxes_prof_graphkit(options)
+      prof_graphkit(options.absorb({outfile: :fluxes, exclude_perturbed_fluxes: true}))
+    end
+    # Graphs plotting quantities from the '.pbalance' file vs rho for a given t_index
+    def pbalance_prof_graphkit(options)
+      prof_graphkit(options.absorb({outfile: :pbalance}))
+    end
+    def prof_graphkit(options)
+      raise "Please specify t_index" unless options[:t_index]
+      it = options[:t_index] - 1
+      if ta  = options[:time_average]
+        if ta < 0
+          t_indices = (it+ta..it).to_a
+        else
+          t_indices = (it..it+ta).to_a
+        end
+      else
+        t_indices = [it]
+      end
+      array = t_indices.map{|i| get_2d_array_float(options[:outfile], options[:header], /1.*time/)[i].to_gslv}.mean.to_a
+      rho_array = t_indices.map{|i| get_2d_array_float(options[:outfile], options[:radius_match]||/2.*radius/, /1.*time/)[i].to_gslv}.mean.to_a
+      if options[:exclude_perturbed_fluxes]
+        #s = array.size
+        array = array.slice(0...nrad-1)
+        rho_array = rho_array.slice(0...nrad-1)
+      end
+      #p rho_array, array
+      kit = GraphKit.autocreate(x: {data: rho_array.to_gslv, title: 'rho', units: ''},
+                          y: {data: array.to_gslv, title: options[:title]||"", units: options[:units]||""}
+                         )
+      kit.data[0].title += " at time = #{list(:t)[it+1]} s for id #{id}"
+      kit.data[0].gp.with = 'lp'
+      kit
+    end
+    # Graph of Qi in gyroBohm units against rho for a given t_index
+    def ion_hflux_gb_prof_graphkit(options)
+      fluxes_prof_graphkit(options.absorb({header: /Qi.*\(GB/, title: 'Ion Heat Flux', units: 'Q_gB'}))
+    end
+    # Graph of Qi in MW against rho for a given t_index
+    def ion_hflux_prof_graphkit(options)
+      fluxes_prof_graphkit(options.absorb({header: /Qi.*\(MW/, title: 'Ion Heat Flux', units: 'MW'}))
+    end
+    # Graph of Qe in gyroBohm units against rho for a given t_index
+    def eln_hflux_gb_prof_graphkit(options)
+      fluxes_prof_graphkit(options.absorb({header: /Qe.*\(GB/, title: 'Electron Heat Flux', units: 'Q_gB'}))
+    end
+    # Graph of Qe in MW against rho for a given t_index
+    def eln_hflux_prof_graphkit(options)
+      fluxes_prof_graphkit(options.absorb({header: /Qe.*\(MW/, title: 'Electron Heat Flux', units: 'MW'}))
+    end
+    # Graph of toroidal angular momentum flux in gyroBohm units against rho for a given t_index
+    def lflux_gb_prof_graphkit(options)
+      fluxes_prof_graphkit(options.absorb({header: /Pi.*\(GB/, title: 'Toroidal Angular Momentum Flux', units: 'Pi_gB'}))
+    end
+    # Graph of toroidal angular momentum against rho for a given t_index
+    def ang_mom_prof_graphkit(options)
+      return nt_prof_graphkit(options.absorb({header: /ang\s+mom/, title: 'Angular Momentum', units: ''}))
+    end
+    # Graph of Ti against rho for a given t_index
+    def ion_temp_prof_graphkit(options)
+      return nt_prof_graphkit(options.absorb({header: /i\+ temp/, title: 'Ti', units: 'keV'}))
+    end
+    # Graph of Te against rho for a given t_index
+    def eln_temp_prof_graphkit(options)
+      return nt_prof_graphkit(options.absorb({header: /e\- temp/, title: 'Te', units: 'keV'}))
+    end
+    # Graph of n against rho for a given t_index
+    def dens_prof_graphkit(options)
+      return nt_prof_graphkit(options.absorb({header: /dens/, title: 'n', units: '10^20 m^-3'}))
+    end
 
-		# Graph of ion power integrated from the magnetic axis to rho vs rho
-		def ion_pwr_prof_graphkit(options)
-			return pbalance_prof_graphkit(options.absorb({header: /i\+ pwr/, title: 'Integrated ion power', units: 'MW'}))
-		end
-		# Graph of electron power integrated from the magnetic axis to rho vs rho
-		def eln_pwr_prof_graphkit(options)
-			return pbalance_prof_graphkit(options.absorb({header: /e\- pwr/, title: 'Integrated electron power', units: 'MW'}))
-		end
-		# Graph of ion power integrated from the magnetic axis to rho vs rho
-		def torque_prof_graphkit(options)
-			return pbalance_prof_graphkit(options.absorb({header: /torque/, title: 'Integrated torque', units: 'Nm'}))
-		end
+    # Graph of ion power integrated from the magnetic axis to rho vs rho
+    def ion_pwr_prof_graphkit(options)
+      return pbalance_prof_graphkit(options.absorb({header: /i\+ pwr/, title: 'Integrated ion power', units: 'MW'}))
+    end
+    # Graph of electron power integrated from the magnetic axis to rho vs rho
+    def eln_pwr_prof_graphkit(options)
+      return pbalance_prof_graphkit(options.absorb({header: /e\- pwr/, title: 'Integrated electron power', units: 'MW'}))
+    end
+    # Graph of ion power integrated from the magnetic axis to rho vs rho
+    def torque_prof_graphkit(options)
+      return pbalance_prof_graphkit(options.absorb({header: /torque/, title: 'Integrated torque', units: 'Nm'}))
+    end
 
     def integrate_profkit(kit, area_vectors, t_indices)
       datavecs = kit.data.map{|d| d.y.data}
@@ -122,7 +122,7 @@ class CodeRunner::Trinity
       end
 
     end
-	end
+  end
 
   # Graph of the ion heat calibration factor
   def ion_hflux_calibration_graphkit(options)
@@ -146,7 +146,7 @@ class CodeRunner::Trinity
     k
   end
 
-	include TrinityGraphKits
+  include TrinityGraphKits
 
   module TrinityMultiKits
     def profiles_graphkit(options)
@@ -187,35 +187,37 @@ class CodeRunner::Trinity
 
   include TrinityMultiKits
 
-	# This is the hook that is called by CodeRunner, providing the
-	# graphkit with the given name and functions to the CodeRunner framework 
-	def graphkit(name, options)
-		[:t].each do |var|
-			#ep 'index', var
-			if options[var].class == Symbol and options[var] == :all
-				options[var] = list(var).values
-			elsif options[var+:_index].class == Symbol and options[var+:_index] == :all
-				#ep 'Symbol'
-				options[var+:_index] = list(var).keys
-			end
-			if options[var].class == Array
-				return options[var].map{|value| graphkit(name, options.dup.absorb({var =>  value}))}.sum
-			elsif options[var+:_index].class == Array
-				#ep 'Array'
-				return options[var+:_index].map{|value| graphkit(name, options.dup.absorb({var+:_index =>  value}))}.sum
-			end
-			if options[var].class == Symbol and options[var] == :max
-				options[var] = list(var).values.max
-			elsif options[var+:_index].class == Symbol and options[var+:_index] == :max
-				ep 'Symbol'
-				options[var+:_index] = list(var).keys.max
-			end
-		end
-		if (meth = TrinityGraphKits.instance_methods.find{|m| m.to_s == name + '_graphkit'} or 
+  # This is the hook that is called by CodeRunner, providing the
+  # graphkit with the given name and functions to the CodeRunner framework 
+  def graphkit(name, options)
+    [:t].each do |var|
+      #ep 'index', var
+      if options[var].class == Symbol and options[var] == :all
+        options[var] = list(var).values
+      elsif options[var+:_index].class == Symbol and options[var+:_index] == :all
+        #ep 'Symbol'
+        options[var+:_index] = list(var).keys
+      end
+      if options[var].class == Array
+        return options[var].map{|value| graphkit(name, options.dup.absorb({var =>  value}))}.sum
+      elsif options[var+:_index].class == Array
+        #ep 'Array'
+        return options[var+:_index].map{|value| graphkit(name, options.dup.absorb({var+:_index =>  value}))}.sum
+      end
+      if options[var].class == Symbol and options[var] == :max
+        options[var] = list(var).values.max
+      elsif options[var+:_index].class == Symbol and options[var+:_index] == :max
+        ep 'Symbol'
+        options[var+:_index] = list(var).keys.max
+      end
+    end
+    if (meth = TrinityGraphKits.instance_methods.find{|m| m.to_s == name + '_graphkit'} or 
         meth = TrinityMultiKits.instance_methods.find{|m| m.to_s == name + '_graphkit'})
-			return send(meth, options)
-		else
-			raise	"GraphKit not found: #{name}"
-		end	
-	end
+      return send(meth, options)
+    elsif name =~ /^nc_/
+      return smart_graphkit(options.absorb({graphkit_name: name}))
+    else
+      raise "GraphKit not found: #{name}"
+    end 
+  end
 end

data/lib/trinitycrmod/namelists.rb

@@ -902,11 +902,30 @@
        :autoscanned_defaults=>[".false."]},
      :calib_option=>
       {:should_include=>"true",
-       :description=>
-        "Sets interpolation of the calibration factor. 'default', 'piecewise_linear', or 'spline'.",
-       :help=>
-        "Which interpolation method to use for the calibration factor. 'default', 'piecewise_linear', or 'spline'.",
+       :description=>" Option for interpolating calib factor",
+       :help=>" Option for interpolating calib factor",
        :code_name=>:calib_option,
+       :must_pass=>
+        [{:test=>"kind_of? String",
+          :explanation=>"This variable must be a string."}],
+       :type=>:String,
+       :autoscanned_defaults=>["default"]},
+     :n_gpus=>
+      {:should_include=>"true",
+       :description=>"Number of gpus avail for gryfx sims",
+       :help=>
+        "If running with gryfx, specify the number of gpus, i.e. the number of simulataneous gryfx simulations.",
+       :code_name=>:n_gpus,
+       :must_pass=>
+        [{:test=>"kind_of? Integer",
+          :explanation=>"This variable must be an integer."}],
+       :type=>:Integer},
+     :flux_shell_script=>
+      {:should_include=>"true",
+       :description=>"A shell script to calculate the fluxes.",
+       :help=>
+        "When running with flux_option = shell, a shell script to calculate the fluxes that is executed during get fluxes.",
+       :code_name=>:flux_shell_script,
        :must_pass=>
         [{:test=>"kind_of? String",
           :explanation=>"This variable must be a string."}],
@@ -924,7 +943,7 @@
         [{:test=>"kind_of? String",
           :explanation=>"This variable must be a string."}],
        :type=>:String,
-       :autoscanned_defaults=>["default", "iterdb"]},
+       :autoscanned_defaults=>["default"]},
      :init_file=>
       {:should_include=>"true",
        :description=>" file with input data",
@@ -1107,7 +1126,7 @@
           :explanation=>
            "This variable must be a fortran boolean. (In Ruby this is represented as a string: e.g. '.true.')"}],
        :type=>:Fortran_Bool,
-       :autoscanned_defaults=>[".false.", ".true."]},
+       :autoscanned_defaults=>[".false."]},
      :flux_groups=>
       {:should_include=>"true",
        :description=>" The number of processors for each flux calculation",
@@ -1129,7 +1148,7 @@
           :explanation=>
            "This variable must be a fortran boolean. (In Ruby this is represented as a string: e.g. '.true.')"}],
        :type=>:Fortran_Bool,
-       :autoscanned_defaults=>[".false.", ".true."]},
+       :autoscanned_defaults=>[".false."]},
      :peaking_factor=>
       {:should_include=>"true",
        :description=>

data/lib/trinitycrmod/read_netcdf.rb

@@ -0,0 +1,157 @@
+# This module reads data from the new diagnostics output file
+# <run_name>.out.nc.
+#
+# It defines a new
+# generic reader function which can read any variable in the new
+# netcdf file using a standard set of index constraints
+#
+
+class CodeRunner::Trinity
+module ReadNetcdf
+
+def new_netcdf_file
+  if (open = @runner.run_list.keys.find_all{|id|  @runner.run_list[id].cache[:new_netcdf_file]}).size > 200
+    open = open.sort_by{|id| @runner.run_list[id].cache[:new_netcdf_file_otime]}
+    @runner.run_list[open[0]].new_ncclose
+  end
+
+  if cache[:new_netcdf_file] and not [:Complete, :Failed].include? @status
+    new_ncclose
+  end
+  cache[:new_netcdf_file_otime] = Time.now.to_i
+  cache[:new_netcdf_file] ||= NumRu::NetCDF.open(new_netcdf_filename)
+  cache[:new_netcdf_file].sync
+  cache[:new_netcdf_file]
+end
+
+def new_netcdf_filename
+  @directory + '/' +  @run_name + '.out.nc'
+end
+def new_ncclose
+  cache[:new_netcdf_file].close
+  cache.delete(:new_netcdf_file)
+end
+
+
+end #module ReadNetcdf
+include ReadNetcdf
+
+class NetcdfSmartReader
+  def initialize(file)
+    @file = file
+  end
+  def dimensions(varname)
+    #p 'varname', varname
+    raise "Unknown variable #{varname}" unless @file.var(varname)
+    @file.var(varname).dims
+  end
+  def read_variable(varname, options)
+    #start = get_start(dims, options)
+    dims = dimensions(varname)
+    narray = @file.var(varname).get('start'=>starts(dims, options), 'end'=>ends(dims, options))
+    if options[:modify_variable]
+      myhsh = dims.inject({}){|hsh, dim|
+        opts = options.dup
+        opts[:modify_variable] = nil
+        dimval = read_variable(dimension_variable_name(dim.name), opts)
+        hsh[dim.name] = dimval
+        hsh
+      }
+      narray = options[:modify_variable].call(varname, narray, myhsh)
+    end
+    shape = narray.shape
+    shape.delete_if{|i| i==1}
+    #p 'shape', shape; STDIN.gets
+    narray.reshape!(*shape)
+    narray
+
+  end
+  def starts(dims, options)
+    dims.map{|d| dim_start(d.name, options)}
+  end
+  def dim_start(name, options)
+    sym = name.to_sym
+    if i=options[sym + :_index]
+      return i-1
+    elsif i=options[sym + :_element]
+      return i
+    elsif i=options[sym + :min]
+      return i
+    else
+      return 0
+    end
+  end
+  def ends(dims, options)
+    dims.map{|d| dim_end(d.name, options)}
+  end
+  def dim_end(name, options)
+    sym = name.to_sym
+    if i=options[sym + :_index]
+      return i-1
+    elsif i=options[sym + :_element]
+      return i
+    elsif i=options[sym + :max]
+      return i
+    else
+      return -1
+    end
+  end
+
+  def axiskit(variable, options)
+    case variable
+    when 'nmat', 'tspec', 'iter'
+      return GraphKit::AxisKit.autocreate(data: GSL::Vector.linspace(1, sz=@file.dim(variable).length, sz), title: variable)
+    end
+    GraphKit::AxisKit.autocreate(data: read_variable(variable, options), units: @file.var(variable).att('units').get, title: @file.var(variable).att('description').get.sub(/(,|summed|average).*$/, '').sub(/[vV]alues of (the )?/, '').sub(/ coordinate/, ''))
+  end
+  def dimension_variable_name(n)
+    case n
+    when 't','tspec', 'iter', 'rad', 'cc', 'nmat'
+      n
+    else
+      raise "Unknown dimension #{n}"
+    end
+  end
+  def check_no_r(non_flat_dims)
+    raise "Please specify the r index for real or imaginary" if non_flat_dims.include? @file.dim('r')
+  end
+  def graphkit(variable, options)
+    non_flat_dims=dimensions(variable).find_all{|dim| dim_start(dim.name, options) != dim_end(dim.name, options) and dim.length != 1}
+    check_no_r(non_flat_dims)
+    axiskits = non_flat_dims.map{|dim| dimvar = dimension_variable_name(dim.name); axiskit(dimvar, options)} + [axiskit(variable, options)]
+    hash = {}
+    axes = [:x, :y, :z, :f]
+    axiskits.each_with_index{|ax, i| hash[axes[i]] = ax}
+    kit = GraphKit.autocreate(hash)
+    opts = options.dup
+    opts.delete(:modify_variable)
+    opts.delete(:graphkit_name)
+    #kit.data[0].title += " with options: " + opts.to_s
+    kit.data[0].title += " " + opts.to_s.gsub(/_(index|element)/, '')
+    if kit.zlabel
+      kit.zlabel = "'#{kit.zlabel}' rotate by 90"
+      #kit.zlabel = nil
+    end
+    kit
+  end
+end # class NetcdfSmartReader
+
+
+def netcdf_smart_reader
+  NetcdfSmartReader.new(new_netcdf_file)
+end
+
+def smart_graphkit(options)
+  case options[:command]
+  when :help
+    "A smart graphkit is a direct plot of a given variable from the new netcdf file. The name of the graphkit is the name of the variable prefixed by 'cdf_'. To plot, for example, the heat flux vs time, you would give the graph name cdf_heat_flux_tot. You can use index specifiers in the the options; for example, to plot the potential as a function of kx and ky for a given time index, you would use the graph name cdf_phi2_by_mode, and the options {t_index: n}. To plot the potential as function of kx for a given ky and time would use the options {t_index, n, Y_index: m}. For each dimension you can specify the index, or a minium and/or maximum."
+  when :options
+    [:nmat_index, :t_index, :tspec_index, :iter_index]
+  else
+    netcdf_smart_reader.graphkit(options[:graphkit_name].sub(/^nc_/, ''), options)
+  end
+end
+
+
+
+end

data/lib/trinitycrmod/trinity.rb

@@ -25,6 +25,8 @@ class CodeRunner
     require 'trinitycrmod/actual_parameter_values'
     require 'trinitycrmod/chease'
     require 'trinitycrmod/calib'
+    require 'trinitycrmod/flux_interpolator'
+    require 'trinitycrmod/read_netcdf'
 
     # Setup gs2 in case people are using it
     CodeRunner.setup_run_class('gs2')

data/sync_variables/helper.rb

@@ -7,12 +7,8 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
-require 'test/unit'
-require 'shoulda'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'coderunner'
 
-class Test::Unit::TestCase
-end

data/trinitycrmod.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: trinitycrmod 0.6.9 ruby lib
+# stub: trinitycrmod 0.7.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "trinitycrmod"
-  s.version = "0.6.9"
+  s.version = "0.7.0"
 
   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-03-31"
+  s.date = "2015-07-11"
   s.description = "This module allows Trinity, the Multiscale Gyrokinetic Turbulent Transport solver for Fusion Reactors, to harness the power of CodeRunner, a framework for the automated running and analysis of simulations."
   s.email = "edmundhighcock@sourceforge.net"
   s.extra_rdoc_files = [
@@ -31,9 +31,11 @@ Gem::Specification.new do |s|
     "lib/trinitycrmod/chease.rb",
     "lib/trinitycrmod/check_parameters.rb",
     "lib/trinitycrmod/deleted_variables.rb",
+    "lib/trinitycrmod/flux_interpolator.rb",
     "lib/trinitycrmod/graphs.rb",
     "lib/trinitycrmod/namelists.rb",
     "lib/trinitycrmod/output_files.rb",
+    "lib/trinitycrmod/read_netcdf.rb",
     "lib/trinitycrmod/trinity.rb",
     "lib/trinitycrmod/trinity_gs2.rb",
     "sync_variables/helper.rb",
@@ -42,40 +44,37 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/edmundhighcock/trinitycrmod"
   s.licenses = ["GPLv3"]
-  s.rubygems_version = "2.2.2"
+  s.rubygems_version = "2.4.8"
   s.summary = "CodeRunner module for the Trinity simulation software."
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<coderunner>, [">= 0.15.5"])
-      s.add_runtime_dependency(%q<text-data-tools>, [">= 1.1.3"])
+      s.add_runtime_dependency(%q<coderunner>, [">= 0.16.10"])
+      s.add_runtime_dependency(%q<text-data-tools>, [">= 1.1.6"])
       s.add_runtime_dependency(%q<gs2crmod>, [">= 0.11.76"])
-      s.add_development_dependency(%q<shoulda>, ["= 3.0.1"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_development_dependency(%q<bundler>, ["> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, [">= 1.8.4"])
-      s.add_development_dependency(%q<minitest>, ["~> 4"])
+      s.add_development_dependency(%q<jeweler>, [">= 2.00"])
     else
-      s.add_dependency(%q<coderunner>, [">= 0.15.5"])
-      s.add_dependency(%q<text-data-tools>, [">= 1.1.3"])
+      s.add_dependency(%q<coderunner>, [">= 0.16.10"])
+      s.add_dependency(%q<text-data-tools>, [">= 1.1.6"])
       s.add_dependency(%q<gs2crmod>, [">= 0.11.76"])
-      s.add_dependency(%q<shoulda>, ["= 3.0.1"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_dependency(%q<bundler>, ["> 1.0.0"])
-      s.add_dependency(%q<jeweler>, [">= 1.8.4"])
-      s.add_dependency(%q<minitest>, ["~> 4"])
+      s.add_dependency(%q<jeweler>, [">= 2.00"])
     end
   else
-    s.add_dependency(%q<coderunner>, [">= 0.15.5"])
-    s.add_dependency(%q<text-data-tools>, [">= 1.1.3"])
+    s.add_dependency(%q<coderunner>, [">= 0.16.10"])
+    s.add_dependency(%q<text-data-tools>, [">= 1.1.6"])
     s.add_dependency(%q<gs2crmod>, [">= 0.11.76"])
-    s.add_dependency(%q<shoulda>, ["= 3.0.1"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])
     s.add_dependency(%q<bundler>, ["> 1.0.0"])
-    s.add_dependency(%q<jeweler>, [">= 1.8.4"])
-    s.add_dependency(%q<minitest>, ["~> 4"])
+    s.add_dependency(%q<jeweler>, [">= 2.00"])
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trinitycrmod
 version: !ruby/object:Gem::Version
-  version: 0.6.9
+  version: 0.7.0
 platform: ruby
 authors:
 - Edmund Highcock
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-31 00:00:00.000000000 Z
+date: 2015-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coderunner
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.15.5
+        version: 0.16.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.15.5
+        version: 0.16.10
 - !ruby/object:Gem::Dependency
   name: text-data-tools
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.3
+        version: 1.1.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.3
+        version: 1.1.6
 - !ruby/object:Gem::Dependency
   name: gs2crmod
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,16 @@ dependencies:
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -100,28 +100,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.4
+        version: '2.00'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.4
-- !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'
+        version: '2.00'
 description: This module allows Trinity, the Multiscale Gyrokinetic Turbulent Transport
   solver for Fusion Reactors, to harness the power of CodeRunner, a framework for
   the automated running and analysis of simulations.
@@ -144,9 +130,11 @@ files:
 - lib/trinitycrmod/chease.rb
 - lib/trinitycrmod/check_parameters.rb
 - lib/trinitycrmod/deleted_variables.rb
+- lib/trinitycrmod/flux_interpolator.rb
 - lib/trinitycrmod/graphs.rb
 - lib/trinitycrmod/namelists.rb
 - lib/trinitycrmod/output_files.rb
+- lib/trinitycrmod/read_netcdf.rb
 - lib/trinitycrmod/trinity.rb
 - lib/trinitycrmod/trinity_gs2.rb
 - sync_variables/helper.rb
@@ -172,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: CodeRunner module for the Trinity simulation software.