mesa_script 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca9b7036396472f5a9ea98119ef282a875bac4e8
+  data.tar.gz: 6e2c6f0ffa3ef59365fd03815ea81b88fa5b316c
+SHA512:
+  metadata.gz: 46b15cee048454f84c79bfc6deaafe9356b91cfd60959599b7d874ab3a80194118d88e19c91b0ce26e9084933c65f52f8f37624b0f56a2c40b9fab78c75c5f0e
+  data.tar.gz: 28b1bc30eec9a956f760b30fda344c54f869f266fc94cc305c5893ce704efe9d13c629ba32256730dcadd799966faff035250b3f0547880604d7bfc92a3c772f

data/README.md

@@ -0,0 +1,292 @@
+MesaScript
+==========
+
+###MESA Requirement!
+In its current state, MesaScript requires MESA rev. 5596 or above. This is due
+to a sensitivity to where the `'.inc'` files are stored on earlier versions. If
+there is demand for MesaScript for earlier revisions, I will look into making
+it backward compatible.
+
+###The Short Short Version
+To get up and running fast, skip to installation, then try and use the included
+sample file, `sample.rb` (via running `ruby sample.rb` in the command line). The
+comments in `sample.rb` should get you started, especially if you have at least
+a little Ruby know-how.
+###What is MesaScript?
+Lightweight, Ruby-based language that provides a powerful way to make inlists
+for MESA projects. Really, MesaScript is a DSL (domain-specific language) built
+on top of Ruby, so Ruby code "just works" inside MesaScript (if you're familiar
+with it, think of what SASS is to CSS, but on a smaller scale).
+
+### What does MesaScript do?
+MesaScript provides a way to build inlists for use with
+[MESA](http://mesa.sourceforge.net) using Ruby, though you need not know much
+at all about Ruby to use it. The main point is that you can use
+variables when creating an inlist, making a reusable template for parameter
+space studies when only a few inlist commands vary between a large number of
+inlists. Most, if not all, of what MesaScript does can be done by using MESA's
+`run_star_extras` hooks, but for the purposes of documenting what I do with
+MESA, I find inlists more enlightening, and I try to stick to high-level
+languages whenever I can.
+
+There are other benefits, too. MesaScript automatically checks your input to
+make sure that the types of arguments you give for various namelist items match
+what is expected, and the resulting inlist is neatly formatted and sensibly
+ordered. You can also easily convert an existing inlist to MesaScript for
+editing and further generalization. In general, *writing an inlist in*
+*MesaScript is no more difficult than writing a normal inlist, but you have far*
+*more flexibility*. So why not give it a try?
+
+If you know a little Ruby (want to learn?
+[Try Ruby here!](http://tryruby.org/levels/1/challenges/0)), the possibilities
+are pretty wide open. You could easily make a script that starts with a given
+set of parameters, run MESA star, then use the output of that run to dictate a
+new inlist and run, creating a chain (maybe a MESA root find of sorts).
+
+###Installation
+Someday, I hope to package this as a gem, but for now, it's staying hosted on
+Github, which means you need to install it yourself. Clone or otherwise
+download the repository somewhere to your home directory with
+
+    git clone https://github.com/wmwolf/MesaScript.git ~/MesaScript
+
+or somewhere else to your liking.
+
+Then, either copy the file `mesa_script.rb` to somewhere along Ruby's path, or
+set up another stand-in file that points to your `mesa_script.rb` file in
+Ruby's path. To find Ruby's path, type
+
+    ruby -e 'puts $:'
+
+in your terminal. If Ruby is properly configured, as it is on most modern Unix
+systems, you should see a list of possible directories. Either copy
+`mesa_script.rb` there or do what I do and make a new file called
+`mesa_script.rb` there and have it just be
+
+    require '/PATH/TO/YOUR/CLONED/REPOSITORY/mesa_script.rb'
+
+This way, if you later update your repo via `git pull`, you won't need to copy
+`mesa_script.rb` again. Also, if you'd like to use the included (optional)
+`inlist2mesascript` tool, copy that to somewhere along you system's path (
+`echo $PATH`). Then type `inlist2mesascript -h` to learn more about that tool.
+As you
+might guess, it takes an existing MESA inlist and converts it to a file in
+MesaScript that, if executed by Ruby should produce essentially the same inlist
+(good for moving a project to MesaScript).
+
+To check if Ruby can see the file, try doing `ruby -e 'require "mesa_script"'`.
+If no error occurs, it is working fine.
+
+Finally, you must have your `MESA_DIR` environment variable set for anything to
+work. The `mesa_script.rb` file generates all the necessary data it needs from
+the MESA source on the fly (this also makes it nearly MESA version
+independent).
+
+###Basic Usage
+The `mesa_script.rb` file defines just one class, Inlist, which we'll interact
+with primarily through one class method, `make_inlist`. Just put the following
+in a file to make a blank inlist:
+
+    require 'mesa_script'
+
+    Inlist.make_inlist('babys_first_inlist') {
+      # inlist commands go here
+    }
+
+This creates a file called `babys_first_inlist` that will be pretty
+boring. It will create three namelists (the usual `star_job`, `controls`, and
+`pgstar`) and leaves them blank inside, which is a perfectly acceptable inlist
+for MESA to use, since it has defaults available. Now let's say you put this in
+a file called `my_first_mesascript.rb` (`.rb` is the extension for Ruby files,
+by the way). Then to actually generate the inlist, enter
+`ruby my_first_mesascript.rb` at the command line and watch in awe as
+`babys_first_inlist` pops into existence. You've created an inlist using
+MesaScript, and you did so using fewer lines than it would have taken to
+actually make that inlist on your own (technically)!
+
+###Entering Inlist Commands
+Making blank inlists is boring, so now let's cover how you actually make useful
+inlists. For mesa inlists, there are really only two types of declarations:
+those for scalars and those for array. Let's talk about scalars first, since
+they are far more common. Then we'll get to the more complicated array
+assignments.
+
+####Scalar Assignments
+As an example, let's say we want to set the initial mass of our star to 2.0
+solar masses. The inlist command for this is `initial_mass`. In a regular
+inlist file, we would need to put this in the proper namelist, `&controls` as
+`initial_mass = 2.0`. In MesaScript, there are two ways to do this:
+
+    initial_mass 2.0    # this
+    initial_mass(2.0)   # is the same as this
+
+In Ruby, parentheses are optional for method calls, so either way is
+acceptable. Note that unlike in normal inlists, MesaScript doesn't care about
+the namelist this attribute belongs to. It'll figure it out on its own and
+place it appropriately.
+
+**WARNING**: You *cannot* use the standard inlist notation of
+
+    initial_mass = 2.0  # DON'T EVER DO THIS EVER EVER EVER
+
+it will *not* throw an error, because it will simply set a new Ruby variable
+called `initial_mass`. (For the person curious as to why I didn't program this
+functionality in, google something like "instance_eval setter method" to
+discover what took me too long to figure out.)
+
+####Array Assignments
+As an example, let's say we want to set a lower limit on a certain central
+abundance as a stopping condition. Then we would, at the minimum, need to set
+the inlist command `xa_central_lower_limit_species(1) = 'h1'`, for example. In MesaScript, there are three ways to do this:
+
+    xa_central_lower_limit_species[1] = 'h1'    # These are
+    xa_central_lower_limit_species(1, 'h1')     # all the
+    xa_central_lower_limit_species 1, 'h1'      # same
+
+**WARNING**: Again, the standard inlist notation for array assignment will not
+work:
+
+    xa_central_lower_limit_species(1) = 'h1'    # THIS ENDS IN SADNESS
+
+I tried to program this functionality in, and the kind people at
+[StackOverflow](http://stackoverflow.com/questions/21036873/how-do-i-write-a-method-to-edit-an-array-hash-using-parentheses-instead-of-squar/21044781?noredirect=1#21044781) kindly but firmly convinced me it was utterly impossible to to with Ruby without writing a parser of my own. Just stick to the bracket syntax or the less natural parentheses/space notations.
+
+####Other Details
+That's really all you need to know to start making inlists with MesaScript,
+though I should remind you, especially if you aren't familiar with Ruby, about
+the basic types of entries you might use. Most inlist commands are one of the
+following: booleans, strings, floats, or integers.
+
+**Booleans** in Ruby are `true` and `false` (case matters, and no periods).
+
+**Strings** work the same as in fortran, though
+single quotes are more "literal" than double quotes. Double quotes allow for
+escaped characters and string interpolation using the `#{...}` notation, which
+might be useful. For instance,
+
+    my_mass = 2.0
+    initial_mass = my_mass
+    save_model true
+    save_model_filename "my_star_#{my_mass}.mod"
+
+will produce (among other things) the line
+`save_model_filename = 'my_star_2.0.mod'` in the resulting inlist. Note also the
+utility of having the initial mass and the save file name being dependent on a
+single variable.
+
+**Integers** are just
+integers (I don't know of a useful literal other than just typing out the
+entire number, though you can use underscores to make it clearer, e.g.
+`100_000_000` is the same as `100000000` in Ruby).
+
+**Floats** use an "e", and never a "d" for an exponential indicator, e.g.
+`6.02e23`. Ruby floats have arbitrary precision, so there are no doubles.
+
+Finally, if a particular command is giving you trouble, you can always just encase what you *want* it to be (i.e. in Fortran lingo) in quotes (obviously this does nothing useful if MesaScript is expecting a string). For example
+
+    mass_change 1e-7
+
+will have the same effect as
+
+    mass_change '1d-7'
+
+since MesaScript will not try to parse `'1d-7'`. It was expecting a float, but
+since it got a string, it assumes you know better than it.
+
+A useful tidbit is that methods are case sensitive to a point. They have the
+same "spelling" as what is found in the `.inc` file (like
+`star/private/star_controls.inc`), but every method has an aliased method that
+is the same, but all in lower case, so you don't need to remember the
+capitalization so long as you remember the actual spelling.
+
+Any Ruby inside the `make_inlist` block will be executed normally, and it can
+see variables named outside of the block. So if you have some basic parameters
+that can determine a large number of inlist commands, you can simply name those
+parameters as variables at the top of your MesaScript file and then make the
+actual MesaScript code weave them into your inlist appropriately. This way, the
+actual parameter changing from inlist to inlist is taken outside of the actual
+inlist commands so you don't forget to change a particular command when you
+move on to a different run (like forgetting to change a `LOG_dir`, which I've
+done a few too many times and thus overwritten some data).
+
+###Deeper and Deeper...
+Are you still reading this? Well, you must want to do more.
+
+###Using Custom Namelists
+You can also make MesaScript know about additional namelists (or forget about
+the standard three). After requiring the `mesa_script` file, you can change the
+namelists it cares about via the following commands (obviously subbing out any
+string containing `'namelist1'` or `'namelist2'` with your own appropriate
+strings):
+
+    require 'mesa_script'
+
+    Inlist.namelists = ['namelist1', 'namelist2'] # all namelists you want
+
+    # Then indicate the name of the '.inc' files like star/private/star_controls.inc
+    Inlist.nt_files  = {
+      'namelist1' => 'namelist1_controls.inc',
+      'namelist2' => 'namelist2_controls.inc'
+    }
+    # Then indicate the names of the '.defaults' files like those in star/defaults
+    Inlist.d_files = {
+      'namelist1' => 'namelist1.defaults,
+      'namelist2' => 'namelist2.defaults
+    }
+    # Then specify the paths to the files
+    Inlist.nt_paths ={
+      'namelist1' => '/path/to/namelist1_controls.inc',
+      'namelist2' => '/path/to/namelist2_controls.inc'
+    }
+
+That *should* set things up to work with custom namelists, so long as the
+`.inc` and `.defaults` files are formatted more or less the same as the "stock"
+ones.
+
+###Accessing Current Values and Displaying Default Values
+Perhaps you want to display a default value in your inlist, but not actually
+change it. Well, most of the assignment methods mentioned earlier
+are also getter methods. I haven't mentioned how these methods actually work, so I'll do so now since you're still reading this manifesto.
+
+These methods first flag the name of the data category for going into the
+inlist. Then if a new value is supplied to them, it changes the value in the
+`Inlist` object's internal hash. Then, when all the user-supplied code has been
+executed, it gathers all the flagged data and formats it into
+properly-formatted namelists, which it then prints out in sequence to the file
+name provided by the user. One final note about these methods, they always
+return the value associated with the inlist object (the new one if you assign
+it, or the current/default value if you don't set one).
+
+So if you want to access any scalar, just call its method without an argument.
+Not only does this return the default value, but it also flags the category for
+inclusion in the inlist so
+
+    save_this_value = initial_mass
+
+will set `save_this_value` to `1.0` (the default value in `controls.defaults`)
+unless you had already assigned another value, in which case that would be saved
+instead. Additionally, `initial_mass = 1.0` will appear in the final inlist,
+even though we didn't give `initial_mass` a new value. In fact, we could just
+have a line like
+
+    initial_z
+
+that neither uses the return value nor changes the stored value. This will just
+flag `initial_z` for being put in the final inlist. Note that there is
+currently no way to unflag an inlist item.
+
+For arrays, things work like you might expect. Any time any one of the versions
+of the array methods are called, that entire array category is staged for
+inclusion in the inlist. For example, you could do any of the following:
+
+    xa_central_lower_limit      # returns a hash of values
+    xa_central_lower_limit[1]   # returns the value associated with 1 in the hash
+    xa_central_lower_limit(1)   # same as above
+    xa_central_lower_limit 1    # same as above
+
+Note that these array methods, as indicated, point to hashes (not arrays) of
+values. So `xa_central_lower_limit_species[1] = 'h1'` would return
+`{1 => 'h1'}`.
+
+##Further Work
+I warmly welcome bug reports, feature suggestions, and most all, pull requests!

data/bin/inlist2mesascript

@@ -0,0 +1,24 @@
+#! /usr/bin/env ruby
+
+require 'mesa_script'
+
+if ARGV.size == 0 or %w[-h --help].include?(ARGV[0])
+  puts ''
+  puts "inlist2mesascript help:"
+  puts '-----------------------'
+  puts "Only one command, which converts an inlist to a mesascript file:"
+  puts ''
+  puts 'inlist2mesascript SOURCE OUTPUT.rb'
+  puts ''
+  puts 'where SOURCE is your mesa inlist and OUTPUT is the name of the'
+  puts "mesascript file to be produced. '.rb' will not be appended, though"
+  puts "the resulting file will be a ruby/mesascript file."
+  puts ''
+elsif ARGV.size == 2
+  source = ARGV[0]
+  output = ARGV[1]
+
+  Inlist.inlist_to_mesascript(source, output, false)
+else
+  raise "Expected two arguments (received #{ARGV.size}). Enter 'inlist2mesa -h' for help."
+end

data/lib/mesa_script.rb

@@ -0,0 +1,618 @@
+InlistItem = Struct.new(:name, :type, :value, :namelist, :order, :is_arr,
+                        :num_indices, :flagged)
+
+class Inlist
+
+
+  @inlist_data = {}
+  # Different namelists can be added or subtracted if MESA should change or
+  # proprietary inlists are required. Later hashes should be edited in a
+  # similar way to get the desired behavior for additional namelists.
+
+  #################### ADD NEW NAMELISTS HERE ####################
+  @namelists = %w{ star_job controls pgstar }
+  ################## POINT TO .INC FILES HERE ####################
+  @nt_files = {
+                'star_job' => %w{star_job_controls.inc},
+                'controls' => %w{star_controls.inc ctrls_io.f},
+                'pgstar'   => %w{pgstar_controls.inc}
+              }
+  # User can specify a custom name for a namelist defaults file. The default
+  # is simply the namelist name followed by '.defaults'
+
+  ################ POINT TO .DEFAULTS FILES HERE #################
+  @d_files = {}
+
+  # User can add new paths to namelist default files through this hash
+
+  ############ GIVE PATHS TO .INC AND .DEF FILES HERE ###########
+  @nt_paths = Hash.new(ENV['MESA_DIR'] + '/star/private/')
+  @d_paths = Hash.new(ENV['MESA_DIR'] + '/star/defaults/')
+
+
+############### NO MORE [SIMPLE] USER-CUSTOMIZABLE FEATURES BELOW ##############
+
+  # This tells the class to initialize its structure if it hasn't already.
+  # If new namelists are added after an instance is initialized, this can be
+  # redone manually by the Inlist.get_data command.
+  @have_data = false
+
+  # Set up interface to access/change customizable inlist initialization data.
+  # Establish class instance variables
+  class << self
+    attr_accessor :have_data
+    attr_accessor :namelists, :nt_paths, :d_paths, :inlist_data, :d_files,
+                  :nt_files
+  end
+
+  # Generate methods for the Inlist class that set various namelist parameters.
+  def self.get_data
+    Inlist.namelists.each do |namelist|
+      @inlist_data[namelist] = Inlist.get_namelist_data(namelist,
+        Inlist.nt_files[namelist], Inlist.d_files[namelist])
+    end
+    # create methods (interface) for each data category
+    @inlist_data.each_value do |namelist_data|
+      namelist_data.each do |datum|
+        if datum.is_arr
+          Inlist.make_parentheses_method(datum)
+        else
+          Inlist.make_regular_method(datum)
+        end
+      end
+    end
+    # don't do this nonsense again unles specifically told to do so
+    Inlist.have_data = true
+  end
+
+  # Three ways to access array categories. All methods will cause the
+  # data category to be staged into your inlist, even if you do not change it
+  # Basically, if it appears in your mesascript, it will definitely appear
+  # in your inlist. There is no way to unflag an entry.
+  #
+  # 1. Standard array way like
+  #        xa_lower_limit_species[1] = 'h1'
+  #    (note square braces, NOT parentheses). Returns new value.
+  #
+  # 2. Just access (and flag), but don't change via array access, like
+  #        xa_lower_limit_species[1]
+  #    (again, note square braces). Returns current value
+  #
+  # 3. No braces method, like
+  #        xa_lower_limit_species()           # flags and returns hash of values
+  #        xa_lower_limit_species             # same, but more ruby-esque
+  #        xa_lower_limit_species(1)          # flags and returns value 1
+  #        xa_lower_limit_species 1           # Same
+  #        xa_lower_limit_species(1, 'h1')    # flags and sets value 1
+  #        xa_lower_limit_species 1, 'h1'     # same
+  #
+  # For multi-dimensional arrays, things are even more vaired. You can treat 
+  # them like 1-dimensional arrays with the "index" just being an array of
+  # indices, for instance:
+  # 
+  #        text_summary1_name[[1,2]] = 'star_mass' # flags ALL values and sets
+  #        text_summary1_name([1,2], 'star_mass')  # text_summary1_name(1,2)
+  #        text_summary1_name [1,2], 'star_mass    # to 'star_mass'
+  #
+  #        text_summary1_name [1,2]                # flags ALL values and 
+  #        text_summary1_name([1,2])               # returns 
+  #                                                # text_sumarry_name(1,2)
+  # 
+  #        text_summary_name()                     # flags ALL values and 
+  #        text_summary_name                       # returns entire hash for
+  #                                                # text_summary_name
+  #
+  # Alternatively, can use the more intuitive form where indices are separate
+  # and don't need to be in an array, but this only works with the parentheses
+  # versions (i.e. the first option directly above has no counterpart):
+  #
+  #        text_summary1_name(1, 2, 'star_mass')
+  #        text_summary1_name 1, 2, 'star_mass'    # same as above (first 3)
+  #        
+  #        text_summary1_name
+  
+  def self.make_parentheses_method(datum)
+    name = datum.name
+    num_indices = datum.num_indices
+    define_method(name + '[]=') do|arg1, arg2|
+      if num_indices > 1
+        raise "First argument of #{name}[]= (part in brackets) must be an array with #{num_indices} indices since #{name} is a multi-dimensional array." unless (arg1.is_a?(Array) and arg1.length == num_indices)
+      end
+      self.flag_command(name)
+      self.data_hash[name].value[arg1] = arg2
+    end
+    define_method(name + '[]') do |arg|
+      if num_indices > 1
+        raise "Argument of #{name}[] (part in brackets) must be an array with #{num_indices} indices since #{name} is a multi-dimensional array." unless (arg.is_a?(Array) and arg.length == num_indices)
+      end
+      self.flag_command(name)
+      self.data_hash[name].value[arg]
+    end
+    define_method(name) do |*args|
+      self.flag_command(name)
+      case args.length
+      when 0 then self.data_hash[name].value
+      when 1
+        if num_indices > 1
+          raise "First argument of #{name} must be an array with #{num_indices} indices since #{name} is a multi-dimensional array OR must provide all indices as separate arguments." unless (args[0].is_a?(Array) and args[0].length == num_indices)
+        end
+        self.data_hash[name].value[args[0]]  
+      when 2
+        if num_indices == 1 and (not args[0].is_a?(Array))
+          self.data_hash[name].value[args[0]] = args[1]
+        elsif num_indices == 2 and (not args[0].is_a?(Array)) and args[1].is_a?(Fixnum)
+          self.data_hash[name].value[args]
+        elsif num_indices > 1
+          raise "First argument of #{name} must be an array with #{num_indices} indices since #{name} is a multi-dimensional array OR must provide all indices as separate arguments." unless (args[0].is_a?(Array) and args[0].length == num_indices)
+          self.data_hash[name].value[args[0]] = args[1]
+        else
+          raise "First argument of #{name} must be an array with #{num_indices} indices since #{name} is a multi-dimensional array OR must provide all indices as separate arguments. The optional final argument is what the #{name} would be set to. Omission of this argument will simply flag #{name} to appear in the inlist."   
+        end 
+      when num_indices
+        self.data_hash[name].value[args]
+      when num_indices + 1
+        raise "Bad arguments for #{name}. Either provide an array of #{num_indices} indices for the first argument or provide each index in succession, optionally specifying the desired value for the last argument." if args[0].is_a?(Array)
+        self.data_hash[name].value[args[0..-2]] = args[-1]
+      else
+        raise "Wrong number of arguments for #{name}. Can provide zero arguments (just flag command), one argument (array of indices for multi-d array or one index for 1-d array), two arguments (array of indices/single index for multi-/1-d array and a new value for the value), #{num_indices} arguments where the elements themselves are the right indices (returns the specified element of the array), or #{num_indices + 1} arguments to set the specific value and return it."
+      end      
+    end
+    alias_method name.downcase.to_sym, name.to_sym
+    alias_method (name.downcase + '[]').to_sym, (name + '[]').to_sym
+    alias_method (name.downcase + '[]=').to_sym, (name + '[]=').to_sym
+  end
+
+  # Two ways to access/change scalars. All methods will cause the data category
+  # to be staged into your inlist, even if you do not change the value.
+  # Basically, if it appears in your mesascript, it will definitely appear in
+  # your inlist. There is no way to unflag an entry.
+  #
+  # 1. Change value, like
+  #        initial_mass(1.0)
+  #        initial_mass 1.0
+  #    This flags the category to go in your inlist and changes the value. There
+  #    is no difference between these two syntaxes (it's built into ruby).
+  #    Returns new value.
+  #
+  # 2. Just access, like
+  #        initial_mass()
+  #        initial_mass
+  #    This flags the category, but does not change the value. Again, both
+  #    syntaxes are allowed, though the one without parentheses is more
+  #    traditional for ruby (why do you want empty parentheses anyway?). Returns
+  #    current value.
+
+  def self.make_regular_method(datum)
+    name = datum.name
+    define_method(name) do |*args|
+      self.flag_command(name)
+      return self.data_hash[name].value if args.empty?
+      self.data_hash[name].value = args[0]
+    end
+    aliases = [(name + '=').to_sym,
+               (name.downcase + '=').to_sym,
+               name.downcase.to_sym]
+    aliases.each { |ali| alias_method ali, name.to_sym }
+  end
+
+
+  # Ensure provided value's data type matches expected data type. Then convert
+  # to string for printing to an inlist. If value is a string, change nothing
+  # (no protection). If value is a string and SHOULD be a string, wrap it in
+  # single quotes.
+  def self.parse_input(name, value, type)
+    if value.class == String
+      if type == :string
+        value = "'#{value}'" unless value[0] == "'" and value[-1] == "'"
+      end
+      return value
+    elsif type == :bool
+      unless [TrueClass, FalseClass].include?(value.class)
+        raise "Invalid value for namelist item #{name}: #{value}. Use " +
+        "'.true.', '.false.', or a Ruby boolean (true/false)."
+      end
+      if value == true
+        return '.true.'
+      elsif value == false
+        return '.false.'
+      else
+        raise "Error converting value #{value} of #{name} to a boolean."
+      end
+    elsif type == :int
+      raise "Invalid value for namelist item #{name}: #{value}. Must provide"+
+      " an int or float." unless value.is_a?(Integer) or value.is_a?(Float)
+      if value.is_a?(Float)
+        puts "WARNING: Expected integer for #{name} but got #{value}. Value" + 
+             " will be converted to an integer."
+      end
+      return value.to_i.to_s
+    elsif type == :float
+      raise "Invalid value for namelist item #{name}: #{value}. Must provide " +
+      "an int or float." unless value.is_a?(Integer) or value.is_a?(Float)
+      return sprintf("%g", value).sub('e', 'd')
+    elsif type == :type
+      puts "WARNING: 'type' values are currently unsupported (regarding #{name}) because your humble author has no idea what they look like in an inlist. You should tell him what to do at wmwolf@physics.ucsb.edu. Your input, #{value}, has been passed through to your inlist verbatim."
+      return value.to_s
+    else
+      raise "Error parsing value for namelist item #{name}: #{value}. Expected "
+            "type was #{type}."
+    end
+  end
+
+  # Converts a standard inlist to its equivalent mesascript formulation.
+  # Comments are preserved and namelist separators are converted to comments.
+  # Note that comments do NOT get put back into the fortran inlist through
+  # mesascript. Converting an inlist to mesascript and then back again will
+  # clean up and re-order your inlist, but all comments will be lost. All other
+  # information SHOULD remain intact.
+  def self.inlist_to_mesascript(inlist_file, script_file, dbg = false)
+    Inlist.get_data unless Inlist.have_data       # ensure we have inlist data
+    inlist_contents = File.readlines(inlist_file)
+
+    # make namelist separators comments
+    new_contents = inlist_contents.map do |line|
+      case line
+      when /^\s*&/  then '# ' + line.chomp        # start namelist
+      when /^\s*\// then '# ' + line.chomp        # end namelist
+      else
+        line.sub('!', '#').chomp                  # fix comments
+      end
+    end
+    new_contents.map! do |line|
+      if line =~ /^\s*#/ or line.strip.empty?     # leave comments and blanks
+        result = line
+      else
+        if dbg
+          puts "parsing line:"
+          puts line
+        end
+        comment_pivot = line.index('#')
+        if comment_pivot
+          command = line[0...comment_pivot]
+          comment = line[comment_pivot..-1].to_s.strip
+        else
+          command = line
+          comment = ''
+        end
+        command =~ /(^\s*)/                       # save leading space
+        leading_space = Regexp.last_match(1)
+        command =~ /(\s*$)/                       # save buffer space
+        buffer_space = Regexp.last_match(1)
+        command.strip!                            # remove white space
+        name, value = command.split('=').map { |datum| datum.strip }
+        if dbg
+          puts "name: #{name}"
+          puts "value: #{value}"
+        end
+        if name =~ /\((\d+)\)/                    # fix 1D array assignments
+          name.sub!('(', '[')
+          name.sub!(')', ']')
+          name = name + ' ='
+        elsif name =~ /\((\s*\d+\s*,\s*)+\d\s*\)/ # fix multi-D arrays
+          # arrays become hashes in MesaScript, so rather than having multiple
+          # indices, the key becomes the array of indices themselves, hence
+          # the double braces replacing single parentheses
+          name.sub!('(', '[[')          
+          name.sub!(')', ']]')
+          name = name + ' ='
+        end
+        name.downcase!
+        if value =~ /'.*'/ or value =~ /".*"/
+          result = name + ' ' + value             # leave strings alone
+        elsif %w[.true. .false.].include?(value.downcase)
+          result = name + ' ' + value.downcase.gsub('.', '') # fix booleans
+        elsif value =~ /\d+\.?\d*([eEdD]\d+)?/
+          result = name + ' ' + value.downcase.sub('d', 'e') # fix floats
+        else
+          result = name + ' ' + value             # leave everything else alone
+        end
+        result = leading_space + result + buffer_space + comment
+        if dbg
+          puts "parsed to:"
+          puts result
+          puts ''
+        end
+      end
+      result
+    end
+    File.open(script_file, 'w') do |f|
+      f.puts "require 'mesa_script'"
+      f.puts ''
+      f.puts "Inlist.make_inlist('#{File.basename(inlist_file)}') do"
+      new_contents.each { |line| f.puts '  ' + line }
+      f.puts "end"
+    end
+  end
+
+
+  # Create an Inlist object, execute block of commands that presumably populate
+  # the inlist, then write the inlist to a file with the given name. This is
+  # the money routine with user-supplied commands in the instance_eval block.
+  def self.make_inlist(name = 'inlist', &block)
+    inlist = Inlist.new
+    inlist.instance_eval(&block)
+    inlist.stage_flagged
+    File.open(name, 'w') { |f| f.write(inlist) }
+  end
+
+  # Checks to see if the data/methods for the Inlist class has been initialized.
+  def self.have_data?
+    @have_data
+  end
+
+  # Reads names and types for a specified namelist from given file (intended
+  # to be of the form of something like star/private/star_controls.inc).
+  #
+  # Returns an array of InlistItem Struct instances that contain a parameter's
+  # name, type (:bool, :string, :float, :int, or :type), the namelist it
+  # belongs to, and its relative ordering in that namelist. Bogus defaults are
+  # assigned according to the object's type, and the ordering is unknown.
+
+  def self.get_namelist_data(namelist, nt_filename = nil, d_filename = nil)
+    temp_data = Inlist.get_names_and_types(namelist, nt_filename)
+    Inlist.get_defaults(temp_data, namelist, d_filename)
+  end
+
+  def self.get_names_and_types(namelist, nt_filenames = nil)
+    nt_filenames ||= Inlist.nt_files[namelist]
+    unless nt_filenames.respond_to?(:each)
+      nt_filenames = [nt_filenames]
+    end
+    nt_full_paths = nt_filenames.map { |file| Inlist.nt_paths[namelist] + file }
+
+    namelist_data = []
+
+    nt_full_paths.each do |nt_full_path|
+      unless File.exists?(nt_full_path)
+        raise "Couldn't find file #{nt_full_path}"
+      end
+      contents = File.readlines(nt_full_path)
+
+      # Throw out comments and blank lines, ensure remaining lines are a proper
+      # Fortran assignment, then remove leading and trailing white space
+      contents.reject! { |line| is_comment?(line) or is_blank?(line) }
+      contents.map! do |line|
+        my_line = line.dup
+        my_line = my_line[0...my_line.index('!')] if has_comment?(my_line)
+        my_line.strip!
+      end
+      full_lines = []
+      contents.each_with_index do |line, i|
+        break if line =~ /\A\s*contains/
+        next unless line =~ /::/
+        full_lines << Inlist.full_line(contents, i)
+      end
+      pairs = full_lines.map do |line|
+        line.split('::').map { |datum| datum.strip}
+      end
+      pairs.each do |pair|
+        type = case pair[0]
+        when /logical/ then :bool
+        when /character/ then :string
+        when /real/ then :float
+        when /integer/ then :int
+        when /type/ then :type
+        else
+          raise "Couldn't determine type of entry #{pair[0]} in " +
+                "#{nt_full_path}."
+        end
+        name_chars = pair[1].split('')
+        names = []
+        paren_level = 0
+        name_chars.each do |char|
+          if paren_level > 0 and char == ','
+            names << '!'
+            next
+          elsif char == '('
+            paren_level += 1
+          elsif char == ')'
+            paren_level -= 1
+          end
+          names << char
+        end
+        names = names.join.split(',').map { |name| name.strip }
+        names.each do |name|
+          is_arr = false
+          num_indices = 0
+          if name =~ /\(.*\)/
+            is_arr = true
+            num_indices = name.count('!') + 1
+            name.sub!(/\(.*\)/, '')
+          end
+          type_default = {:bool => false, :string => '', :float => 0.0,
+                          :int => 0}
+          dft = is_arr ? Hash.new(type_default[type]) : type_default[type]
+          namelist_data << InlistItem.new(name, type, dft, namelist, -1, is_arr,
+                                          num_indices)
+        end
+      end
+    end
+    namelist_data
+  end
+
+  # Similar to Inlist.get_names_and_types, but takes the output of
+  # Inlist.get_names_and_types and assigns defaults and orders to each item.
+  # Looks for this information in the specified defaults filename.
+
+  def self.get_defaults(temp_data, namelist, d_filename = nil, whine = false)
+    d_filename ||= namelist + '.defaults'
+    d_full_path = Inlist.d_paths[namelist] + d_filename
+    raise "Couldn't find file #{d_filename}" unless File.exists?(d_full_path)
+    contents = File.readlines(d_full_path)
+    contents.reject! { |line| is_comment?(line) or is_blank?(line) }
+    contents.map! do |line|
+      my_line = line.dup
+      if has_comment?(line)
+        my_line = my_line[0...my_line.index('!')]
+      end
+      raise "Equal sign missing in line:\n\t #{my_line}\n in file " +
+        "#{full_path}." unless my_line =~ /=/
+      my_line.strip!
+    end
+    pairs = contents.map {|line| line.split('=').map {|datum| datum.strip}}
+    n_d_hash = {}
+    n_o_hash = {}
+    pairs.each_with_index do |pair, i|
+      name = pair[0]
+      default = pair[1]
+      if name =~ /\(.*\)/
+        selector = name[/\(.*\)/][1..-2]
+        name.sub!(/\(.*\)/, '')
+        if selector.include?(':')
+          default = Hash.new(default)
+        elsif selector.count(',') == 0
+          default = {selector.to_i => default}
+        else
+          selector = selector.split(',').map { |index| index.strip.to_i }
+          default = default = {selector => default}
+        end
+      end
+      if n_d_hash[name].is_a?(Hash)
+        n_d_hash[name].merge!(default)
+      else
+        n_d_hash[name] = default
+      end
+      n_o_hash[name] ||= i
+    end
+    temp_data.each do |datum|
+      unless n_d_hash.keys.include?(datum.name)
+        puts "WARNING: no default found for control #{datum.name}. Using standard defaults." if whine
+      end
+      default = n_d_hash[datum.name]
+      if default.is_a?(Hash) and datum.value.is_a?(Hash)
+        datum.value = datum.value.merge(default)
+      else
+        datum.value = default || datum.value
+      end
+      datum.order = n_o_hash[datum.name] || datum.order
+    end
+    temp_data
+  end
+
+  def self.full_line(lines, i)
+    return lines[i] unless lines[i][-1] == '&'
+    [lines[i].sub('&', ''), full_line(lines, i+1)].join(' ')
+  end
+
+  def self.is_comment?(line)
+    line =~ /\A\s*!/
+  end
+
+  def self.is_blank?(line)
+    not (line =~/[a-z0-9]+/)
+  end
+
+  def self.has_comment?(line)
+    line.include?('!')
+  end
+
+  # Making an instance of Inlist first checks to see if the class methods are
+  # set up for the namelists in Inlist.namelists. If they aren't ready, it
+  # creates them. Then creates a hash with an array associated to each namelist
+  # that is the exact size of the number of entries available in that namelist.
+
+  attr_accessor :data_hash
+  attr_reader :names
+  def initialize
+    Inlist.get_data unless Inlist.have_data?
+    @data = Inlist.inlist_data
+    @data_hash = {}
+    @data.each_value do |namelist_data|
+      namelist_data.each do |datum|
+        @data_hash[datum.name] = datum.dup
+
+      end
+    end
+    @names = @data_hash.keys
+    @data = {}
+    Inlist.namelists.each do |namelist|
+      @data[namelist] = Array.new(Inlist.inlist_data[namelist].size, '')
+    end
+  end
+
+  # Zeroes out all staged data and blank lines
+  def make_fresh_writelist
+    @to_write = {}
+    @data.keys.each do |namelist|
+      @to_write[namelist] = Array.new(@data[namelist].size, '')
+    end
+  end
+
+  def namelists
+    @data.keys
+  end
+
+  def flag_command(name)
+    @data_hash[name].flagged = true
+  end
+  
+  def unflag_command(name)
+    @data_hash[name].flagged = false
+  end
+
+  def stage_namelist_command(name)
+    datum = @data_hash[name]
+    if datum.is_arr
+      lines = @data_hash[name].value.keys.map do |key|
+        prefix = "  #{datum.name}("
+        suffix = ") = " + 
+        Inlist.parse_input(datum.name, datum.value[key], datum.type) + "\n"
+        if key.respond_to?(:inject)
+          indices = key[1..-1].inject(key[0].to_s) do |res, elt| 
+            "#{res}, #{elt}"
+          end
+        else
+          indices = key.to_s
+        end
+        prefix + indices + suffix
+      end
+      lines = lines.join
+      @to_write[datum.namelist][datum.order] = lines
+    else
+      @to_write[datum.namelist][datum.order] =  "  " + datum.name + ' = ' +
+                Inlist.parse_input(datum.name, datum.value, datum.type) + "\n"
+    end
+  end
+
+  # Marks a data category so that it can be staged into an inlist
+  def flagged
+    @data_hash.keys.select { |key| @data_hash[key].flagged }
+  end
+
+  # Collects all data categories into a hash of arrays (each array is a
+  # namelist) that is read whenever the inlist is converted to a string
+  # (i.e. when it is printed to a file or the screen).
+  def stage_flagged
+    make_fresh_writelist # start from scratch
+
+    flagged.each { |name| stage_namelist_command(name) } # stage each datum
+
+    # blank lines between disparate data
+    namelists.each do |namelist|
+      @to_write[namelist].each_index do |i|
+        next if (i == 0 or i == @to_write[namelist].size - 1)
+        this_line = @to_write[namelist][i]
+        prev_line = @to_write[namelist][i-1]
+      
+        this_line = '' if this_line.nil?
+        prev_line = '' if prev_line.nil?
+        if this_line.empty? and not(prev_line.empty? or prev_line == "\n")
+          @to_write[namelist][i] = "\n"
+        end
+      end
+    end
+  end
+
+  # Takes the staged data categories and formats them into a string series of
+  # namelists that are MESA-readable.
+  def to_s
+    result = ''
+    namelists.each do |namelist|
+      result += "\n&#{namelist}\n"
+      result += @to_write[namelist].join("")
+      result += "\n/ ! end of #{namelist} namelist\n"
+    end
+    result.sub("\n\n\n", "\n\n")
+  end
+
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: mesa_script
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- William Wolf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-21 00:00:00.000000000 Z
+dependencies: []
+description: MesaScript - a DSL for making dynamic inlists for the MESA stellar evolution
+  code.
+email: wmwolf@physics.ucsb.edu
+executables:
+- inlist2mesascript
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/inlist2mesascript
+- lib/mesa_script.rb
+homepage: https://wmwolf.github.io
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: MesaScript is a domain specific language (DSL) that allows the user to write
+  inlists for MESA that include variables, loops, conditionals, etc. For more detailed
+  instructions, see the readme on the github page at   https://github.com/wmwolf/MesaScript  This
+  software requires a relatively modern installation of MESA (version > 5596). It
+  has been tested on Ruby versions > 1.9, but there is no guarantee it will work on
+  older (or newer!) versions. Any bugs or requests should be sent to the author, Bill
+  Wolf, at wmwolf@physics.ucsb.edu.
+test_files: []