gs2crmod 0.5.2

data/lib/gs2crmod/astrogk/properties.rb

@@ -0,0 +1,17 @@
+class CodeRunner
+class Gs2::Astrogk 
+
+
+######################################
+# GS2 CodeRunner Module
+#
+# Calculated Properties
+# 
+# These are methods which calculate
+# miscellaneous properties of the run.
+#
+#####################################
+
+
+end
+end

data/lib/gs2crmod/astrogk/species_dependent_namelists.rb

@@ -0,0 +1,228 @@
+{:species_parameters=>
+  {:description=>"SPECIES ",
+   :include_conditions=>"true",
+   :variables=>
+    {:z=>
+      {:help=>"Charge",
+       :include_conditions=>"true",
+       :description=>"Charge",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :mass=>
+      {:help=>"Mass",
+       :include_conditions=>"true",
+       :description=>"Mass",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :dens=>
+      {:help=>"Density\t",
+       :include_conditions=>"true",
+       :description=>"Density\t",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :temp=>
+      {:help=>"Temperature",
+       :include_conditions=>"true",
+       :description=>"Temperature",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :tprim=>
+      {:help=>"6.0   !-1/T (dT/drho)",
+       :include_conditions=>"true",
+       :description=>"6.0   !-1/T (dT/drho)",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :fprim=>
+      {:help=>"2.22   !-1/n (dn/drho)",
+       :include_conditions=>"true",
+       :description=>"2.22   !-1/n (dn/drho)",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :uprim=>
+      {:help=>"?",
+       :include_conditions=>"true",
+       :description=>"?",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :vnewk=>
+      {:help=>"1.e-2   !collisionality parameter",
+       :include_conditions=>"true",
+       :description=>"1.e-2   !collisionality parameter",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :type=>
+      {:help=>"'ion' Thermal ion species ",
+       :include_conditions=>"true",
+       :description=>"'ion' Thermal ion species ",
+       :tests=>["Tst::STRING"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? String",
+          :explanation=>"This variable must be a string."}]},
+     :dens0=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::FLOAT"],
+       :gs2_name=>:dens0,
+       :must_pass=>
+        {:test=>"kind_of? Numeric",
+         :explanation=>
+          "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."},
+       :autoscanned_defaults=>[1.0]},
+     :u0=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::FLOAT"],
+       :gs2_name=>:u0,
+       :must_pass=>
+        {:test=>"kind_of? Numeric",
+         :explanation=>
+          "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."},
+       :autoscanned_defaults=>[1.0]},
+     :uprim2=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::FLOAT"],
+       :gs2_name=>:uprim2,
+       :must_pass=>
+        {:test=>"kind_of? Numeric",
+         :explanation=>
+          "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."},
+       :autoscanned_defaults=>[0.0]},
+     :nustar=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::FLOAT"],
+       :gs2_name=>:nustar,
+       :must_pass=>
+        {:test=>"kind_of? Numeric",
+         :explanation=>
+          "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."},
+       :autoscanned_defaults=>[-1.0]},
+     :nu=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::FLOAT"],
+       :gs2_name=>:nu,
+       :must_pass=>
+        {:test=>"kind_of? Numeric",
+         :explanation=>
+          "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."},
+       :autoscanned_defaults=>[-1.0]},
+     :nu_h=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::FLOAT"],
+       :gs2_name=>:nu_h,
+       :must_pass=>
+        {:test=>"kind_of? Numeric",
+         :explanation=>
+          "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."},
+       :autoscanned_defaults=>[0.0]},
+     :tperp0=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::FLOAT"],
+       :gs2_name=>:tperp0,
+       :must_pass=>
+        {:test=>"kind_of? Numeric",
+         :explanation=>
+          "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."},
+       :autoscanned_defaults=>[0.0]},
+     :tpar0=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::FLOAT"],
+       :gs2_name=>:tpar0,
+       :must_pass=>
+        {:test=>"kind_of? Numeric",
+         :explanation=>
+          "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."},
+       :autoscanned_defaults=>[0.0]}}},
+ :dist_fn_species_knobs=>
+  {:description=>"",
+   :include_conditions=>"true",
+   :variables=>
+    {:fexpr=>
+      {:help=>
+        "0.5   !Temporal implicitness parameter. Recommended value: 0.48",
+       :include_conditions=>"true",
+       :description=>
+        "0.5   !Temporal implicitness parameter. Recommended value: 0.48",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :fexpi=>
+      {:help=>nil,
+       :include_conditions=>"true",
+       :description=>nil,
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :bakdif=>
+      {:help=>"0.0   !Spatial implicitness parameter. Recommended value: 0.05",
+       :include_conditions=>"true",
+       :description=>
+        "0.0   !Spatial implicitness parameter. Recommended value: 0.05",
+       :tests=>["Tst::FLOAT"],
+       :autoscanned_defaults=>[],
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}]},
+     :bd_exp=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :tests=>["Tst::INT"],
+       :gs2_name=>:bd_exp,
+       :must_pass=>
+        {:test=>"kind_of? Integer",
+         :explanation=>"This variable must be an integer."},
+       :autoscanned_defaults=>["bd_exp_out"]}}}}

data/lib/gs2crmod/astrogk/test_gs2.rb

@@ -0,0 +1,231 @@
+class CodeRunner
+	class Gs2::Astrogk
+		
+		# See TestAstrogk
+		
+		def self.test_gs2(*args)
+			TestAstrogk.test_gs2(*args)
+		end
+		
+		# = Astrogk Test Suite
+		# This class is designed to run a set of functional tests to test the GS2 source. It is not a test suite for GS2crmod, the GS2 CodeRunner module. It takes all the input files from the folder <tt>test_cases</tt>, runs them and checks that they give the same output as the standard case. Only the NetCDF file from the standard case should be included, and should have the same name as the test case input file.
+		
+		module TestAstrogk 
+			
+		
+			# The folder where all the test files are stored.
+			
+			TEST_FOLDER = Dir.pwd #File.dirname(__FILE__) + "../test_cases"
+			
+			
+			# Give the standardised name of the test_results folder, given the name of the test case input file
+			
+			def self.results_folder(input_file)
+				'test_results/' + input_file.sub(/\.in$/, '')
+			end
+			
+			def self.test_case_folder(input_file)
+				TEST_FOLDER + '/' + input_file.sub(/\.in$/, '') 
+			end
+			
+			# The io object all test info is written to.
+			
+			TEST_OUT = STDERR
+			
+			# Run all the test cases. test_case_location should be the folder test_cases in the gs2 source.
+			#
+			# Options are
+			# * restart (default: true) Delete all results and start again.
+			# * submit (default: true) Submit any runs that haven't been submitted.
+			# * serial (default: true) Wait till one test run has finished before starting another
+			
+			def self.test_gs2(test_case_location, options={})
+					Astrogk.send(:include, self)
+					test_case_location.sub!(/~/, ENV['HOME'])
+					TEST_FOLDER.gsub!(/^.*$/, test_case_location)
+					raise "The first argument should be the test_cases folder" unless File.basename(TEST_FOLDER) == "test_cases"
+					@tests_failed = {}
+
+					
+					serial = true unless ["false", false].include? options[:serial]
+					restart = true unless ["false", false].include? options[:restart]
+					submit = true unless ["false", false].include? options[:submit]
+					
+					
+					@test_runner = CodeRunner.fetch_runner(Y: Dir.pwd, u: true)
+					@submitted_tests = @test_runner.runs.map{|run| run.run_name}
+					test_cases = Dir.entries(TEST_FOLDER).find_all do |entry|
+# 						p entry
+						File.directory?(TEST_FOLDER + '/' + entry) and not entry =~ /^\./
+					end
+# 					p test_cases
+					
+					if restart
+						FileUtils.rm_r 'test_results' if FileTest.exist? 'test_results' 
+						FileUtils.makedirs 'test_results'
+					end
+					
+					# Submit the tests
+					if submit
+						test_cases.each do |test_case|
+							next if FileTest.exist? results_folder(test_case)
+							submit_run(test_case)
+							run_tests if serial
+						end
+					end
+					run_tests
+					
+					if @tests_failed.size == 0
+						TEST_OUT.puts "All Tests Completed Successfully"
+						eputs "All Tests Completed Successfully" unless TEST_OUT == STDERR
+					else
+						eputs "Tests Were Failed" 
+						@tests_failed.each do |name, hash|
+							sep = "----------------------------------------------"
+							TEST_OUT.puts '', sep, "                 Test Failed", sep
+							TEST_OUT.puts "Name: #{name}"
+							TEST_OUT.puts "Description: \n#{hash[:description]}", ''
+							TEST_OUT.puts "This test failed on these checks: #{hash[:checks_failed]}", ''
+							TEST_OUT.puts sep, ''
+						end
+					end
+								
+			end
+			
+			# Check to see which run has completed and run tests for those runs.
+			
+			def self.run_tests
+				eputs "Waiting for runs to complete"
+				loop do
+						break if @submitted_tests.size ==0
+						@test_runner.update(false)	
+						i = 0
+						loop do
+							tst = @submitted_tests[0]
+							run = @test_runner.runs.find{|run| run.run_name == tst}
+							if [:Complete, :Failed].include? run.status 
+								run_checks run
+								@submitted_tests.delete(tst)
+							end
+							i += 1
+							break if i >= @submitted_tests.size
+						end
+						sleep 3
+					end
+			end
+
+		
+			# Run the test case with the given input file. 
+			
+			def self.submit_run(test_case)
+				
+				dir = results_folder(test_case)
+				input_text = File.read("#{test_case_folder(test_case)}/#{test_case}.in")
+				
+				description = input_text.scan(Regexp.new("#{/^\s*!\s*description\s*=\s* /}(#{Regexp.quoted_string})")).flatten[0]
+				(eputs "----Rejecting '#{file}', no description provided or description is not in the correct format: description = \" description \"";return) unless description
+				run = Astrogk.new(@test_runner)
+
+				# This cryptic statement updates the run parameters from the input file 
+				run.instance_eval(
+					Astrogk.defaults_file_text_from_input_file("#{test_case_folder(test_case)}/#{test_case}.in"))
+				
+				run.run_name = test_case
+				run.instance_variable_set(:@dir_name, dir)
+				@test_runner.test_submission = true
+				@test_runner.submit(run)
+				
+				other_files = Dir.entries(test_case_folder(test_case)).find_all do |f|
+					not (f =~ /\.in/ or f =~ /\.out\.nc/ or f =~ /\.svn/ or [".", ".."].include? f)
+				end
+				other_files.each do |f|
+# 					p f
+					FileUtils.cp(test_case_folder(test_case)+'/'+f, results_folder(test_case)+'/'+f)
+				end
+				
+				@test_runner.test_submission = false
+				@test_runner.submit(run)
+				@submitted_tests.push run.run_name
+				
+				
+			end
+			
+			def self.run_checks(run)
+				checks_failed = []
+				
+				input_text = File.read("#{test_case_folder(run.run_name)}/#{run.run_name}.in")
+				description = input_text.scan(Regexp.new("#{/^\s*!\s*description\s*=\s* /}(#{Regexp.quoted_string})")).flatten[0]
+				description.gsub!(/(.{25,45} |.{45})/){"#$1\n"} if description
+				if input_text =~ Regexp.new("#{/^\s*!\s*custom_checks\s*=\s* /}(#{Regexp.properly_nested("\\[", "\\]", false)})")
+					custom_checks = eval($1)
+					custom_checks.each{|check| checks_failed.push check unless run.run_check check}
+				else
+					checks_failed.push :standard unless run.run_check :standard
+				end
+				unless checks_failed.size == 0
+					@tests_failed[run.run_name] = {checks_failed: checks_failed, description: description}
+				end
+			end
+			
+			# Relative error which differences cannot exceed in the standard case
+			
+			TOLERANCE = 1.0e-10
+			
+			# A list of variables that are allowed to be different in the standard test
+			
+			EXCLUDED_VARIABLES = ['input_file']
+			
+			# Check the results against standard cases using the checks described here. Any custom tests should be implemented here!
+			
+			def run_check(check)
+				netcdf_standard_case = NumRu::NetCDF.open(TestAstrogk.test_case_folder(@run_name) + '/' + @run_name + '.out.nc')
+				Dir.chdir(@directory) do
+					case check
+					when :standard
+						netcdf = NumRu::NetCDF.open(@run_name + '.out.nc')
+						netcdf.vars.map{|v| v.name}.each do |v|
+							unless netcdf_standard_case.var(v)
+								TEST_OUT.puts "Warning: variable '#{v}' is missing from the test case netcdf output for '#@run_name'. Suggest updating the test case netcdf file. This is not a GS2 fault."
+							end
+						end
+						netcdf_standard_case.vars.map{|v| v.name}.each do |v|
+							next if EXCLUDED_VARIABLES.include? v
+							begin
+								unless netcdf.var(v)
+									TEST_OUT.puts "Error: Variable #{v} is missing from the netcdf output for #@run_name"
+									return false
+								end
+								
+								narray = netcdf.var(v).get
+								standard_narray = netcdf_standard_case.var(v).get
+								
+								if standard_narray.abs.max < TOLERANCE 
+									if narray.abs.max < TOLERANCE 
+										next
+									else
+										TEST_OUT.puts "Error: Variable '#{v}' has failed check in '#@run_name'"
+										return false
+									end
+								end
+								
+								
+								difference = narray - standard_narray
+								return false unless difference.abs.max / standard_narray.abs.max < TOLERANCE
+	# 							ep 'var', difference.abs.max
+							rescue => err
+								TEST_OUT.puts "Error: #{err}"
+								TEST_OUT.puts "Error: Variable '#{v}' has failed check in '#@run_name'"
+								return false
+							end
+						end
+						return true
+					end
+				end
+			end
+				                             
+			
+		end #module TestAstrogk
+		
+	end
+end
+				                  

data/lib/gs2crmod/astrogk.rb

@@ -0,0 +1,200 @@
+##########################################
+# = Code Runner GS2 Module              
+##########################################
+#
+# Authors: Edmund Highcock
+# Copyright: 2009 Edmund Highcock
+#
+# This is free software released under the GPL v3 
+#
+# This module allows easy running of the plasma turbulence simulation code gs2 using Code Runner, by automatically organising, naming and submitting runs, and analysing the run data.
+#
+# See Code Runner documentation, or documentation for individual methods.
+#
+# Notes
+#
+# index variables, e.g. kx_index, ky_index etc always refer to the 1-based Fortran index, to keep correspondance with the gs2 indices. Element variables, e.g. kx_element, always refer to the 0-based C/ruby index
+#
+# raw NumRu::NetCDF grids are in Fortran row-major order. This means that when you access grids using the NetCDF function NetCDF#get, you must specify the indices in fortran order (but 0-based!). The NetCDF#get function then returns a C-like NArray with the indices in the opposite order. You can convert this to a Ruby Array using the method NArray#to_a (the indices will still be in the same order).
+
+
+#
+
+
+
+class CodeRunner
+	
+	
+	#CodeRunner.setup_run_class('g2') # Astrogk Inherits from GS2
+	
+	# This is a customised subclass of CodeRunner::Run which allows CodeRunner to submit and analyse simulations from the gyrokinetic flux tube code AstroGK, which is principally used for simulating plasmas in magnetic confinement fusion.
+	#
+	# It performs two distinct roles: submitting simulations and analysing the data.
+	#
+	# = Submitting Simulations
+	#
+	# This principally involves generating the input file, which is a very nontrivial task. In order to do this, it maintains a complete record of every possible input parameter for AstroGK, as well as what datatype that parameter is, and sometimes what values it is allowed to take. This allows that not only to generate the input file, but to check that the input file makes sense. However, although generating the input file works beautifully, the set of sanity checks that it makes is not exhaustive: intelligent use is still required!
+	# 
+	# In tandem with this, it maintains a whole set of tools for manipulating its database of input parameters. This includes updating their allowed values and also editing and accessing help for every input parameter.
+	#
+	# = Analysing Simulations
+	#
+	# The amount of analysis possible on AstroGK data is enormous, and CodeRunner hasn't got close to getting there. What it can do is:
+	# 
+	# * Check if the run is complete by comparing the number of completed timesteps against nstep
+	# * Calculate growth rates for linear runs.
+	# * Check if non-linear runs have saturated and calculate fluxes for those runs.
+	# * Automatically plot a huge variety of different graphs, ranging from simple plots of heat flux versus time to three-dimensional plots of the spectrum and potential.
+
+
+class Gs2::Astrogk  < Gs2
+
+
+
+def agk?
+	true
+end
+
+# Include the other files
+@code_module_folder = folder = File.dirname(File.expand_path(__FILE__)) + '/astrogk' # i.e. the directory this file is in
+setup_namelists(folder)
+require folder + '/graphs.rb'
+# require folder + '/namelist_tools.rb'
+# require folder + '/input_file_tools.rb'
+require folder + '/gsl_data.rb'
+require folder + '/check_convergence.rb'
+require folder + '/calculations.rb'
+require folder + '/ingen.rb'
+require folder + '/properties.rb'
+require folder + '/test_gs2.rb'
+
+NaN = GSL::NAN
+# GSL::Neg
+
+
+
+
+
+################################################
+# Quantities that are calculated or determined by CodeRunner
+# after the simulation has ended, i.e. quantities
+# that are not available from the AstroGK output files.
+################################################
+# Get GS2 results and add any 
+# astrogk ones (currently empty)
+
+@results = rcp.results + [] 
+
+###############################################
+# Other useful information about the run
+###############################################
+
+@astrogk_run_info = rcp.gs2_run_info + []
+
+@run_info = @astrogk_run_info.dup
+
+
+
+@naming_pars = rcp.naming_pars + []
+
+@code_long = "AstroGK Astrophysical Gyrokinetic Code"
+
+@excluded_sub_folders =[]
+
+def run_namelist_backwards_compatibility
+end
+def set_nprocs
+
+	if (nprocs_in = @nprocs) =~ /^x/
+		max = max_nprocs_no_x
+		#Astrogk seems to not like you actually having naky * nspec * negrid processors.. reduce it
+		for i in 2...max
+			if max%i ==0
+				max = max / i
+				break
+			end
+		end
+		nodes = 0
+		@nprocs = "#{nodes}#{nprocs_in}"	 
+		loop do
+			nodes += 1
+			@nprocs = "#{nodes}#{nprocs_in}"	 
+			if actual_number_of_processors > max 
+				nodes -= 1
+				@nprocs = "#{nodes}#{nprocs_in}"	 
+				break
+			end
+		end
+	end
+end
+def input_file_header
+	<<EOF
+!==============================================================================
+!  		AstroGK INPUT FILE automatically generated by CodeRunner 
+!==============================================================================
+!
+!  AstroGK is a gyrokinetic flux tube initial value turbulence code 
+!  which can be used for fusion or astrophysical plasmas.
+!  
+!  	See http://gyrokinetics.sourceforge.net
+!
+!  CodeRunner is a framework for the automated running and analysis 
+!  of large simulations. 
+!
+!  	See http://coderunner.sourceforge.net
+!      by CodeRunner version #{CodeRunner::CODE_RUNNER_VERSION.to_s}
+!
+!==============================================================================
+
+EOF
+end
+def self.defaults_file_header
+	<<EOF1
+######################################################################
+# Automatically generated defaults file for AstroGK CodeRunner module#
+#                                                                    #
+# This defaults file specifies a set of defaults for AstroGK which are#
+# used by CodeRunner to set up and run GS2 simulations.              #
+#                                                                    #
+# Created #{Time.now.to_s}                                           #
+#                                                                    #
+######################################################################
+
+@defaults_file_description = ""
+EOF1
+end
+
+@source_code_subfolders = ['utils']
+
+folder = File.dirname(File.expand_path(__FILE__)) # i.e. the directory this file is in
+
+def self.transfer_gs2_docs
+	CodeRunner.setup_run_class('gs2')
+	p CodeRunner::Astrogk.ancestors
+	intersection = (CodeRunner::Gs2.rcp.namelists.keys&CodeRunner::Astrogk.rcp.namelists.keys)
+	gs2namelists=CodeRunner::Gs2.rcp.namelists
+	intersection.each do | namelist |
+		p namelist
+	  gs2namelist=gs2namelists[namelist]
+		next unless gs2namelist
+		self.rcp.namelists[namelist][:variables].each do | varname, varhash |
+			p varname
+			if match = (gs2namelist[:variables][varname]) # or gs2namelist[:variables].find{|gs2varname,gs2varhash| gs2varhash[:code_name]==varhash[:code_name]}[1])
+				puts "Found corresponding variable #{varname}"
+				#p match
+				puts "Found help: #{match[:help]}"
+				varhash[:help] = match[:help] if match[:help]
+				varhash[:description] = match[:description]
+				save_namelists
+			end
+		end
+
+	end
+end
+	end # class Astrogk
+	# For backwards compatibility
+  Astrogk = Gs2::Astrogk
+
+end # class CodeRunner
+
+