aims_project_windows 0.3.1

data/README

@@ -0,0 +1,5 @@
+
+Required Gems:
+
+ruby-opengl >= 0.60.1
+wxruby

data/bin/AimsCalc

@@ -0,0 +1,367 @@
+#!/usr/bin/env ruby
+
+#
+# AimsCalc [geometry] [control]
+# 
+# Author: Joshua Shapiro, 2012
+# email: joshua.shapiro@gmail.com
+# 
+# Generate a set of FHI-AIMS calculations from control and geometry files.
+# If the user provides filename on the command line the calculation is generated, 
+# otherwise, the user is prompted for filenames.
+#
+
+begin
+  require 'aims_project'
+  require 'highline'
+rescue
+  require 'rubygems'
+  require 'aims_project'
+end
+
+def usage
+  STDERR.puts <<-END_USAGE
+usage: AimsCalc command [args]
+  Valid commands are:
+  create     - Create a new calculation
+  restart    - Restart an aborted or cancelled calculation using most recent geometry 
+  rerun      - Rerun a calculation using the original geometry and control
+  rename     - Rename a control or geometry file and all dependent calculations  
+  invalidate - Invalidate a geometry or control file and dependent calculations 
+  hold       - Place a STAGED calculation into a HOLD status
+  release    - Release a calculation from HOLD, placing it back in STAGED status
+  setvar     - Set a calculation variable
+  help cmd - For help on a given command
+END_USAGE
+end
+
+def help(cmd)
+  case cmd
+  when /create/
+    puts <<-HELP
+usage: AimsCalc create [geometry] [control]
+Create and stage a new calculation.
+ * geometry is the name of a geometry file
+ * control is the name of a control file
+ 
+ Without arguments, the user will be prompted to select geometry and control files.
+ 
+HELP
+  when /restart/
+    puts <<-HELP
+usage: AimsCalc restart [calculation]
+Restart an aborted or cancelled calculation using most recent available geometry.
+ * The name of a calculation
+ 
+Without arguments, the user will be prompted to select a calculation.
+
+HELP
+  when /status/
+    puts <<-HELP
+usage: AimsCalc status
+Currently just dumps all the status files
+HELP
+  when /rerun/
+    puts <<-HELP
+
+usage: AimsCalc rerun [calculation]
+
+Use this to rerun a calculation for whatever reason.  This will 
+set the calculation status back to staged. run cap aims:enqueue to 
+actually rerun the calculation.
+HELP
+  when /rename/
+    puts <<-HELP
+
+usage: AimsCalc rename [control or geometry]
+
+Renames a control or geometry file and all dependent calculations.
+HELP
+  when /invalidate/
+    puts <<-HELP
+    
+usage: AimsCalc invalidate [geometry or control]
+
+Invalidate a geometry or control file.  This will mark the geometry
+or control file as well as any dependent calculations as INVALID.  
+A warning will be issued if the user tries to use the INVALID input file.
+HELP
+  when /hold/
+    puts <<-HELP
+
+usage: AimsCalc hold calculation
+
+Place a calculation that is currently STAGED into a HOLD status.  This means it will 
+not be QUEUED for calculation.  Use 'release' to re-STAGE the calculation.
+HELP
+  when /release/
+    puts <<-HELP
+    
+usage: AimsCalc release calculation
+
+Set the status for a calculation that is currently on HOLD status to STAGED. 
+This means it will be scheduled for execution the next time enqueue is run.
+HELP
+
+  when /setvar/
+  puts <<-HELP
+  
+usage: AimsCalc setvar var1=value1 var2=value2 ...
+
+Set a project variable. These variables are available for use in 
+geometry and control files using embedded ruby with the @var syntax. 
+
+ex.  
+AimsCalc setvar lattice_const=5.65
+
+Then in a geometry file
+atom 0 0 0 Ga
+atom <%= [@gaas_lattice_const/4 @gaas_lattice_const/4 @gaas_lattice_const/4].join(" ") %> As 
+
+HELP
+  
+  else
+    usage
+  end
+end
+
+# Get the project associated with the current directory 
+# returns nil if unable to find a project
+def project
+  project_obj_files = Dir["*.yaml"]
+  unless project_obj_files.empty?
+    AimsProject::Project.load(project_obj_files.first)
+  else
+    raise AimsProject::AimsProjectException.new("Sorry, I can't tell what project this is.  Please move to the project root directory.")
+  end
+end
+
+# Parse command line arguments of the form a=1 b=2 into a hash 
+# suitable for evaluating in the project binding
+def parse_vars(args)
+  vars = {}
+  
+  # Condition format of input user variables
+  args.each{|arg| 
+    if arg =~ /(.*)=(.*)/
+      # Split key=value pairs
+      symbol = $1
+      value = $2
+      # Prefix all variables with an @
+      sym = if symbol.to_s =~ /^@.*/
+        symbol.to_sym
+      else
+        ("@" + symbol.to_s).to_sym
+      end
+      
+      # Cast value to Float if applicable
+      val = if value =~ /^(\d+\.*\d*)$/
+        $1.to_f
+      elsif value =~ /"(.*)"/ or value =~ /'(.*)'/
+        $1
+      else
+        value
+      end
+      
+      # Set the variable in the Vars hash
+      vars[sym] = val
+    end
+  }
+  vars
+end
+
+# Create a calculation from a geometry and control file. 
+# @param [String] geometry The name of a file that can be found in the geometry directory
+# @param [String] control The name of a file that can be found in the control directory
+# @param [Array<String>] args An array of string key-value pairs in the form of "key=value"
+#        These key-value pairs will be loaded as instance variables into the binding that
+#        is used to evaluate geometry and control.
+def build_calculation(geometry, control, args)
+  begin
+    # a hash to store the user defined variables
+    vars = parse_vars(args)
+    # Load the project variables
+    p = project
+    calc = AimsProject::Calculation.create(p, geometry, control, vars)
+    puts "Created #{calc.calculation_directory}"
+  rescue 
+    puts $!.message
+    puts $!.backtrace
+  end
+end
+
+# Generate a new calculation by calling Calculation::restart_relaxation
+def restart_calculation(calculation)
+  calc = begin
+    AimsProject::Calculation.load(calculation)
+  rescue ObjectFileNotFoundException
+    calc_dir = File.join(AimsProject::CALCULATION_DIR, File.basename(calculation))
+    calc = AimsProject::Calculation.load(calc_dir)
+  end
+  newcalc = calc.restart_relaxation
+  puts "Created #{newcalc.name}"
+end
+
+# Print status information of each calculation
+def calc_statuses
+  def date_str_fmt(dt)
+    case dt
+    when nil
+      "N/A"
+    when Date.today
+      "Today at " + dt.strftime("%H:%M")
+    when Date.today.prev_day
+      "Yesterday"
+    else
+      dt.strftime("%Y-%m-%d")
+    end
+  end
+  def duration_fmt(t)
+    if t < 2
+      "%0.2f hrs" % (t.to_f.abs*24.0)
+    else
+      "%i days ago" % t.round
+    end
+  end
+  def status_fmt(s)
+    color = case s
+    when AimsProject::RUNNING
+      :green
+    when AimsProject::COMPLETE
+      :yellow
+    when AimsProject::CANCELED
+      :red
+    else
+      nil
+    end
+    HighLine.color(s,color)
+  end
+  project_obj_files = Dir["*.yaml"]
+  project = AimsProject::Project.load(project_obj_files.first)
+  format = "%-40s\t%-30s\t%-15s\t%-15s\t%-15s\t%-15s"
+  puts format % ["GEOMETRY", "CONTROL", "STATUS", "CREATED_AT", "UPDATED_AT", "SINCE_UPDATE"]
+  project.calculations.sort{|a, b| a.updated_at <=> b.updated_at}.each{|c|
+    puts format % [c.geometry[0..40], c.control[0..30], status_fmt(c.status), date_str_fmt(c.created_at), date_str_fmt(c.updated_at), duration_fmt(DateTime.now - c.updated_at)]
+  }
+end
+
+# Place the specified calculations on HOLD status if they are staged.
+def hold(calculation)
+  calc = get_calculation_from_string(calculation)
+  if calc.hold
+    puts "Calculation status set to #{calc.status}. Use AimsCalc release to revert to STAGED"
+  else
+    puts "Unable to set status of calculation to HOLD"
+  end
+end
+
+# Release a calculation from HOLD status
+def release(calculation)
+  calc = get_calculation_from_string(calculation)
+  if calc.release
+    puts "Calculation status set to #{calc.status}."
+  else
+    puts "Unable to release calculation from HOLD"
+  end
+end
+
+# Set the calculation status back to staged
+def rerun_calculation(calculation)
+  calc = begin
+    AimsProject::Calculation.load(calculation)
+  rescue ObjectFileNotFoundException
+    calc_dir = File.join(AimsProject::CALCULATION_DIR, File.basename(calculation))
+    calc = AimsProject::Calculation.load(calc_dir)
+  end
+  calc.status = AimsProject::STAGED
+  calc.save
+  puts "Calculation status set to STAGED. Run cap aims:enqueue to execute."
+  puts
+end
+
+def get_calculation_from_string(str)
+  calc = begin
+    AimsProject::Calculation.load(str)
+  rescue ObjectFileNotFoundException
+    calc_dir = File.join(AimsProject::CALCULATION_DIR, File.basename(str))
+    calc = AimsProject::Calculation.load(calc_dir)
+  end  
+  calc
+end
+
+# Rename a geometry or control file and all dependent calculations
+# @param file The name of the original file
+# @param newname The new name for the file
+def rename(file, newname)
+  raise "Sorry... 'AimsCalc rename' isn't implemented yet."
+end
+
+# Set project variables
+def setvar(args)
+  vars = parse_vars(args)
+  p = project
+  vars.each{|sym, val|
+    p.instance_variable_set(sym, val)
+    puts "Setting #{sym} = #{val}"
+  }
+  p.save
+end
+
+# Invalidate each of the geometry or control inputs specified in arguments
+def invalidate(args)
+  args.each {|arg|
+    files =  Dir.glob(File.join(AimsProject::GEOMETRY_DIR, arg))
+    files += Dir.glob(File.join(AimsProject::CONTROL_DIR, arg))
+    files.each{|f|
+      # Write a note in file header
+      puts "I would invalidate #{f} here if I was implemented..."
+      # Find all the dependent calculations
+      
+      # and set their status to invalid
+      
+    }
+  }
+end
+
+# Run the desired command
+begin
+  args = ARGV
+  cmd = args.shift
+  case cmd
+  when /create/
+    build_calculation(args[0], args[1], args[2..-1])
+  when /restart/
+    restart_calculation(args[0])
+  when /status/
+    calc_statuses
+  when /rerun/
+    rerun_calculation(args[0])
+  when /invalidate/
+    invalidate(args)
+  when /rename/
+    rename(args[0], args[1])
+  when /hold/
+    hold(args)
+  when /release/
+    release(args)
+  when /setvar/ 
+    setvar(args)
+  when /help/
+    help(args[0])
+  else
+    usage
+  end
+rescue AimsProject::AimsProjectException => ex
+  STDERR.puts ex.message
+rescue => error
+  STDERR.puts
+  STDERR.puts "Sorry, something went wrong. Please send the following information to joshua.shapiro@gmail.com"
+  STDERR.puts
+  STDERR.puts "FILE:  #{__FILE__}"
+  STDERR.puts "CMD:   #{cmd}"
+  STDERR.puts "ARGS:  #{args.join(" ")}"
+  STDERR.puts "ERROR: " + error.message
+  STDERR.print "\t" + error.backtrace.slice(0..5).join("\n\t")
+  STDERR.puts 
+  STDERR.puts 
+end

data/bin/AimsProject

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+require 'aims_project'
+require 'fileutils'
+require 'highline'
+
+# Initialize an AimsProject
+# Create a directory named by the project
+# and generate the AimsProjectInfo.yaml file 
+
+ui = HighLine.new
+skeleton_dir = File.join(Dir.home, ".aims_project")
+
+unless File.exists?(skeleton_dir)
+  ui.say <<-EOF
+  
+   It looks like this is the first time you are running AimsProject.
+   
+   I can create the directory $HOME/.aims_project which will be the 
+   template for all of your future projects.  Feel free to customize the
+   files in this directory to suit your needs.  In particular, you will
+   want to customize 'Capfile' and 'aims.sh'.  And you may want to add 
+   variables that should be available to any project in 'project_variables.rb'
+   
+   EOF
+   
+   # Copy the skeleton directory tasks into config
+   script_dir = File.join(File.dirname(File.expand_path(__FILE__)), '..', 'skeleton')
+
+  if ui.agree("Can I create #{Dir.home}/.aims_project?")
+    # Create the skeleton directory in $HOME/.aims_project
+    Dir.mkdir skeleton_dir  
+    FileUtils.cp_r(File.join(script_dir, '.'), skeleton_dir)
+  else
+    ui.say("Ok, maybe next time.")
+    skeleton_dir = script_dir
+  end  
+end
+
+# Set the project name and direcory
+projectName = ARGV[0]
+unless projectName
+  projectName = ui.ask("Please specify the name of the project: ", String) {|q| q.whitespace = :remove}.to_s
+end
+
+projectDir = projectName
+
+if project = AimsProject::Project.create(projectName)
+  
+  ui.say "Creating #{projectDir}..."
+  
+  # save the project into a directory named after the project
+  project.save(projectDir)
+  
+  # Copy the skeleton directory tasks into config
+  FileUtils.cp_r(File.join(skeleton_dir, '.'), projectDir)
+  
+  
+  # Generate the default Capfile
+  capfile = ""
+  File.open(File.join(projectDir, "Capfile"), 'r') do |capfile_template|
+    capfile_template.each_line do |line|
+      line.sub!(/__PROJECT_DIR__/, projectDir)
+      line.sub!(/__PROJECT_NAME__/, projectName)
+      capfile << line
+    end
+  end
+  
+  File.open(File.join(projectDir, "Capfile"), 'w') do |f|
+    f.puts capfile
+  end
+  
+  STDOUT.puts <<-EOL
+  
+  Done creating the aims project #{projectName}. Here are the steps to get started.
+  1) Customize the variables in #{File.join(projectDir, "Capfile")}
+  2) Add geometry files to the directory #{File.join(projectDir, AimsProject::GEOMETRY_DIR)}
+  3) Add control files to the directory #{File.join(projectDir, AimsProject::CONTROL_DIR)}
+  4) Generate a calculation with the command:
+      AimsCalc create [geometry] [control]
+  5) Execute the calculations with the command:
+      cap aims:enqueue
+      
+  EOL
+  
+else 
+  STDERR.puts "Error creating project."
+  STDERR.puts $!.message
+end

data/bin/AimsProjectManager

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+
+require "wx"
+require "erb"
+require "gl"
+require "glu"
+
+require 'aims'
+require 'aims_project'
+require 'aims_project/material.rb'
+require 'aims_project/atom.rb'
+require 'aims_project/inspector.rb'
+require 'aims_project/crystal_viewer.rb'
+require 'aims_project/geometry_editor.rb'
+require 'aims_project/geometry_console.rb'
+require 'aims_project/project_tree.rb'
+require 'aims_project/calculation_tree.rb'
+require 'aims_project/app_controller.rb'
+require 'aims_project/geometry_window.rb'
+require 'aims_project/calculation_window.rb'
+require 'aims_project/thread_callback_event.rb'
+require 'aims_project/crystal_viewer_options.rb'
+
+controller = AimsProject::AppController.new
+
+unless __FILE__.nil?
+  cwd = File.expand_path(".")
+  controller.working_dir = cwd
+end
+
+
+# project_obj_files = Dir["*.yaml"]
+# controller.project = AimsProject::Project.load(project_obj_files.first) unless project_obj_files.empty?
+AimsProject::ThreadCallbackEvent.set_event_type(Wx::Event.new_event_type)
+Wx::EvtHandler.register_class(AimsProject::ThreadCallbackEvent, AimsProject::ThreadCallbackEvent.event_type, "evt_thread_callback", 0)
+
+controller.main_loop

data/lib/aims_project/aims_project_exception.rb

@@ -0,0 +1,42 @@
+
+module AimsProject
+  class AimsProjectException < StandardError
+  end
+
+  class InvalidFilenameException < AimsProjectException
+    def initialize(filename)
+      if filename.nil?
+        super "No filename specified"
+      else
+        super "The filename #{filename} is invalid."
+      end
+    end
+  end
+  
+  class ObjectFileNotFoundException < AimsProjectException
+    def initialize(filename)
+      super "The serialized yaml file was not found: #{filename}"
+    end
+  end
+  
+  class CorruptObjectFileException < AimsProjectException
+    def initialize(filename)
+      super "The serialized yaml file is corrupt: #{filename}"
+    end
+  end
+  
+  class GeometryValidationException < AimsProjectException
+    attr_reader :violations
+    def initialize(violations)
+      @violations = violations
+      super "The Geometry failed validation."
+    end
+  end
+  
+  class GeometryEvaluationException < AimsProjectException
+    def initialize
+      super "Error evaluating geometry"
+    end
+  end
+  
+end

data/lib/aims_project/aims_project_geometry.rb

@@ -0,0 +1,52 @@
+module AimsProject
+  
+  # A class that encapsulates the Aims::Geometry and other
+  # state information important for AimsProject
+  class AimsProjectGeometry
+    
+    # Boolean flag indicating whether the atoms should be displaced to all lie
+    # within the unit cell
+    attr_accessor :correct_geometry
+
+    # The filename defining this geometry
+    attr_reader :filename
+    
+    def initialize(file)
+      @filename = file
+      @geometry_original = Aims::GeometryParser.parse(@filename)
+    end
+    
+    def geometry
+      if self.correct_geometry
+        geometry_corrected
+      else
+        geometry_original
+      end
+    end
+    
+    def geometry_corrected
+      if @geometry_corrected.nil?
+        @geometry_corrected = @geometry_original.correct
+      end
+      @geometry_corrected
+    end
+    
+    def geometry_original
+      @geometry_original
+    end
+    
+    def to_s
+      @filename
+    end
+    
+    
+    def save
+      unless @filename
+        raise InvalidFilenameException
+      end
+      raise "AimsProjectGeometry.save is not yet implemented"
+    end
+    
+  end
+  
+end