gs2crmod 0.5.2

data/lib/gs2crmod/astrogk/astrogk.rb

@@ -0,0 +1,201 @@
+##########################################
+# = 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 GS2, 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 GS2, 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 GS2 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.
+
+
+CodeRunner.setup_run_class('gs2')
+class Gs2::Astrogk  < Gs2
+
+ASTROGK_CRMOD_VERSION = Version.new('0.3.0')
+
+
+def agk?
+	true
+end
+
+# Include the other files
+@code_module_folder = folder = File.dirname(File.expand_path(__FILE__)) # 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::Gs2::Astrogk.ancestors
+	intersection = (CodeRunner::Gs2.rcp.namelists.keys&CodeRunner::Gs2::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 Gs2::Astrogk
+	# For backwards compatibility
+
+end # class CodeRunner
+
+

data/lib/gs2crmod/astrogk/calculations.rb

@@ -0,0 +1,57 @@
+##########################################
+# Calculations for AGK Code Runner Module
+# (Only if they differ from GS2)
+#
+# This module contains any methods that
+# begin with the word calculate. 
+#
+# These methods calculate results and 
+# quantities that are not directly 
+# obtainable from the GS2 output files.
+#
+##########################################
+
+
+class CodeRunner
+class Gs2::Astrogk 
+
+	def read_transfers
+		Dir.chdir(@directory) do
+			raise "No ktrans file" unless FileTest.exist? "#@run_name.ktrans"
+		file = File.open("#@run_name.ktrans", "r")
+		wtr_hash = {}
+		etr_hash = {}
+		while line = file.gets
+			#p line;
+			arr =   line.split(/\s+/).map{|w| w.to_f}
+			#p arr
+			dud, t, kf, kt, w, e = arr
+			next unless t 
+			etr_hash[t] ||= {}
+			etr_hash[t][kf] ||= {}
+			etr_hash[t][kf][kt] = e
+
+			wtr_hash[t] ||= {}
+			wtr_hash[t][kf] ||= {}
+			wtr_hash[t][kf][kt] = w
+
+
+
+
+		end
+
+		
+		#p etr_hash
+
+		File.open('energy_transfer.rb', 'w'){|file| file.puts etr_hash.pretty_inspect}
+		File.open('w_transfer.rb', 'w'){|file| file.puts wtr_hash.pretty_inspect}
+
+		end # Dir.chdir(@directory)
+
+	end
+
+
+end
+end
+
+

data/lib/gs2crmod/astrogk/check_convergence.rb

@@ -0,0 +1,7 @@
+class CodeRunner
+class Gs2::Astrogk
+
+	
+
+end
+end

data/lib/gs2crmod/astrogk/deleted_variables.rb

@@ -0,0 +1,76 @@
+{:stir_mode_amplitude=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>nil,
+   :tests=>["Tst::FLOAT"],
+   :code_name=>:stir_mode_amplitude,
+   :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=>:Float},
+ :stir_kx=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>" Mode number for stirring\n",
+   :tests=>["Tst::INT"],
+   :code_name=>:stir_kx,
+   :must_pass=>
+    [{:test=>"kind_of? Integer",
+      :explanation=>"This variable must be an integer."}],
+   :type=>:Integer},
+ :stir_ky=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>" Mode number for stirring\n",
+   :tests=>["Tst::INT"],
+   :code_name=>:stir_ky,
+   :must_pass=>
+    [{:test=>"kind_of? Integer",
+      :explanation=>"This variable must be an integer."}],
+   :type=>:Integer},
+ :stir_kz=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>" Mode number for stirring\n",
+   :tests=>["Tst::INT"],
+   :code_name=>:stir_kz,
+   :must_pass=>
+    [{:test=>"kind_of? Integer",
+      :explanation=>"This variable must be an integer."}],
+   :type=>:Integer},
+ :stir_travel=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>" Launches traveling wave (or standing wave if F). \n",
+   :tests=>["Tst::FORTRAN_BOOL"],
+   :code_name=>:stir_travel,
+   :must_pass=>
+    [{:test=>"kind_of? String and FORTRAN_BOOLS.include? self",
+      :explanation=>
+       "This variable must be a fortran boolean. (In Ruby this is represented as a string: e.g. '.true.')"}],
+   :type=>:Fortran_Bool},
+ :stir_a=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>
+    " Initial amplitude of right-moving component. It is not necessary to set a and b unless you are\ndoing restarts, which are rather clunky at the moment with the antenna included. \n",
+   :tests=>["Tst::FLOAT"],
+   :code_name=>:stir_a,
+   :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=>:Float},
+ :stir_b=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>
+    " Initial amplitude of left-moving component. It is not necessary to set a and b unless you are\ndoing restarts, which are rather clunky at the moment with the antenna included. \n",
+   :tests=>["Tst::FLOAT"],
+   :code_name=>:stir_b,
+   :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=>:Float}}

data/lib/gs2crmod/astrogk/graphs.rb

@@ -0,0 +1,13 @@
+
+
+class CodeRunner
+class Gs2::Astrogk 
+
+module AGKGraphKits 
+		
+end
+
+include AGKGraphKits
+
+end
+end

data/lib/gs2crmod/astrogk/gsl_data.rb

@@ -0,0 +1,13 @@
+class CodeRunner
+	class Gs2::Astrogk
+		module AstrogkGSLVectors
+			def etrans_by_kfrom_by_kto_over_time_gsl_vector(options)
+				read_transfers unless FileTest.exist? "energy_transfer.rb"
+				etr_hash = eval(File.read("energy_transfer.rb"))
+				etr_hash.values.map{|hash| hash[options[:kf]][options[:kt]]}.to_gslv
+
+			end
+		end
+		include AstrogkGSLVectors
+	end
+end

data/lib/gs2crmod/astrogk/gsl_tools.rb

@@ -0,0 +1,182 @@
+###################################
+# GS2 CodeRunner Module: GSL Tools
+# 
+# Various useful methods for manipulating gsl data.
+#
+###################################
+
+module GSL
+	def self.cache
+		@cache ||= {}
+		@cache
+	end
+end
+
+
+class GSL::Vector
+	def pieces(no_pieces)
+		ans = []
+		piece_sizes  = []
+
+		for i in 0...no_pieces 
+			ans.push []; piece_sizes[i] = 0
+		end
+		for j in 0...size 
+			piece_sizes[j % no_pieces] += 1
+		end
+# 		p ans, piece_sizes
+		accum = 0
+		piece_sizes.each_with_index do |piece_size, piece|
+			ans[piece] = self.subvector(accum, piece_size)
+			accum += piece_size
+		end
+		return ans
+	end
+	
+	def from_box_order
+		size = self.size
+		v1, v2 = self.subvector(0, (size+1)/2), self.subvector((size+1)/2, (size-1)/2)
+		return v2.connect(v1)
+	end
+
+end
+
+       
+
+class GSL::Matrix::Complex
+
+	def self.re_im(re, im)
+		raise "Shape of real and imaginary matrices must match" unless re.shape == im.shape
+		rows, cols = re.shape
+		mat = alloc(rows, cols)
+		for i in 0...rows
+			for j in 0...cols
+				mat[i,j] = GSL::Complex.alloc([re[i,j], im[i,j]])
+			end
+		end
+		return mat
+	end
+	
+	
+	def backward_cols_c2c(normalise = false)
+		gm = self.dup
+		rows, cols = gm.shape
+		table = GSL.cache[[:fft_table, :complex, rows]] ||= GSL::FFT::ComplexWavetable.alloc(rows)
+		work = GSL.cache[[:fft_work, :complex, rows]] ||= GSL::FFT::ComplexWorkspace.alloc(rows)
+		for i in 0...cols
+			vec = gm.col(i)
+			vec.backward!(table, work)
+			for j in 0...rows
+				gm[j,i] =  vec[j]
+			end
+		end
+		gm = gm / rows if normalise
+		gm
+	end
+
+	def forward_cols_c2c
+		gm = self.dup
+		rows, cols = gm.shape
+		table = GSL.cache[[:fft_table, :complex, rows]] ||= GSL::FFT::ComplexWavetable.alloc(rows)
+		work = GSL.cache[[:fft_work, :complex, rows]] ||= GSL::FFT::ComplexWorkspace.alloc(rows)
+		for i in 0...cols
+			vec = gm.col(i)
+			vec.forward!(table, work)
+			for j in 0...rows
+				gm[j,i] =  vec[j]
+			end
+		end
+		gm
+	end
+
+	def backward_rows_cc2r(normalise = false)
+		gm = self.dup
+		rows, cols = gm.shape
+	# 	if cols%2 == 0
+	# 		newcols = cols*2
+	# 	else
+	# 		newcols = cols*2 - 1		
+	# 	end
+		was_even = rows.times.inject(true) do |bool, i|
+			bool and (gm[i, cols - 1].imag == 0.0)
+		end
+	# 	ep was_even
+			
+		if was_even
+			newcols = cols * 2 - 2
+		else
+			newcols = cols * 2 - 1
+		end
+		gm_re = GSL::Matrix.alloc(rows, newcols)
+			
+		table = GSL.cache[[:fft_table, :real, newcols]] ||= GSL::FFT::RealWavetable.alloc(newcols)
+		work = GSL.cache[[:fft_work, :real, newcols]] ||= GSL::FFT::RealWorkspace.alloc(newcols)
+		row = GSL::Vector::Complex.alloc(cols)
+	# 	p rows
+		for i in 0...rows
+	# 		p i
+	# 		row = gm.row(i)
+			(0...cols).each{|j| row[j] = gm[i,j]}
+			if was_even
+				vec = row.concat(row.subvector(1, row.size - 2).reverse.conjugate) if cols > 2
+			else
+				vec = row.concat(row.subvector(1, row.size - 1).reverse.conjugate) if cols > 1
+			end
+			vec.backward!(table, work)
+			for j in 0...newcols
+				gm_re[i,j] =  vec[j].real
+			end
+		end
+		gm_re = gm_re / newcols.to_f if normalise
+		gm_re
+	end
+
+end
+
+class GSL::Matrix
+
+	def move_rows_from_box_order
+		rows, cols = self.shape
+		gm1, gm2 = self.view(0,0, (rows + 1)/2, cols), self.view((rows + 1)/2, 0,  (rows - 1)/2, cols)
+		return gm2.vertcat(gm1)
+	end
+	def move_cols_from_box_order
+		rows, cols = self.shape
+		gm1, gm2 = self.view(0,0, rows, (cols + 1)/2), self.view(0, (cols + 1)/2, rows, (cols - 1)/2)
+		return gm2.horzcat(gm1)
+	end
+	
+	
+def forward_rows_r2cc
+	gm = self.dup
+	rows, cols = gm.shape
+	if cols%2 == 0
+		newcols = (cols+2)/2  
+	else
+		newcols = (cols+1)/2		
+	end
+	gm_cc = GSL::Matrix::Complex.alloc(rows, newcols)
+		
+	table = GSL.cache[[:fft_table, :real, cols]] ||= GSL::FFT::RealWavetable.alloc(cols)
+	work = GSL.cache[[:fft_work, :real, cols]] ||= GSL::FFT::RealWorkspace.alloc(cols)
+	row = GSL::Vector.alloc(cols)
+	for i in 0...rows
+		(0...cols).each{|j| row[j] = gm[i,j]}
+# 		p i
+# 		row = gm.get_row(i)
+# 		vec_out = GSL::Vector::Complex.alloc(row.size)
+# 		(0...row.size).each{|j| vec[j] = row[j]}
+# 		if cols%2 == 0
+# 			vec_out = vec.concat(vec.subvector(1, vec.size - 2).reverse.conjugate)
+# 		else
+# 			vec_out = vec.concat(vec.subvector(1, vec.size - 1).reverse.conjugate)
+# 		end
+		view = row.forward(table, work).halfcomplex_to_complex
+		for j in 0...newcols
+			gm_cc[i,j] =  view[j]
+		end
+	end
+	return gm_cc
+end
+	
+end

data/lib/gs2crmod/astrogk/ingen.rb

@@ -0,0 +1,18 @@
+class CodeRunner
+class Gs2::Astrogk 
+
+ def ingen
+
+	 # Misc Errors
+
+	 warning("Write k energy transfer currently only works with  layout = 'yxles'") if @write_ktrans and @write_ktrans.fortran_true? and not @layout == "yxles"
+
+	 super # call GS2 ingen
+ end
+
+	def diagnostics_namelist
+		:diagnostics
+	end
+end
+end
+

data/lib/gs2crmod/astrogk/input_file_tools.rb

@@ -0,0 +1,7 @@
+
+
+class CodeRunner
+class Gs2::Astrogk 
+
+end
+end

data/lib/gs2crmod/astrogk/namelist_tools.rb

@@ -0,0 +1,14 @@
+#########################
+# GS2 CodeRunner module
+# Namelist Constants
+#########################
+
+
+#
+
+class CodeRunner
+class Gs2::Astrogk
+
+
+end
+end