aims_project_windows 0.3.1

data/lib/aims_project/calculation.rb

@@ -0,0 +1,406 @@
+
+require 'fileutils'
+require 'erb'
+require 'date'
+
+#
+# A calculation is a combination of a geometry, a control file, and an output
+# Each calculation runs in its own directory
+# A special file named .calc_status in the calculation directory reveals the status of the calculation
+# The format of this file is still under consideration.
+# possible options are:
+#  • A single word indicating the status
+#  • A single word on the first line and unstructured text following (for comments, history, errors)
+#  • YAML
+#
+# The calculation progresses through the following state machine
+#   STAGED:
+#       This is the initial stage, before the calculation has been 
+#       moved to the computation server and queued for execution. 
+#       Valid inputs are CANCEL, ENQUEUE
+#   QUEUED:
+#       Calculation is uploaded to computation server and queued for execution.
+#       Valid inputs are CANCEL, PROGRESS
+#   RUNNING:
+#       Calculation is in progress.
+#       Valid inputs are CANCEL
+#   COMPLETE:
+#       Calculation is completed
+#       No valid inputs
+#   ABORTED:
+module AimsProject
+
+  class Calculation
+
+    # The name of the geometry file
+    attr_accessor :geometry 
+    
+    # The name of the control file
+    attr_accessor :control 
+    
+    # The current calculation status
+    attr_accessor :status
+
+    # The calculation subdirectory, (can be nil)
+    attr_accessor :calc_subdir
+
+    # An array of (#to_s) items that are the calculation history  
+    attr_accessor :history
+
+    # Timestamp indicating creation of this calculation
+    attr_writer :created_at
+    def created_at
+      @created_at = cast_as_date(@created_at)
+    end
+    
+    # Timestamp indicating last update of this calculation
+    # (currently only updates when saved)
+    attr_writer :updated_at
+    def updated_at
+      # Cast value to Date
+      # Do this in the accessor because loading from YAML bypasses the setter method
+      @updated_at = cast_as_date(@updated_at)
+    end
+
+    def cast_as_date(obj)
+      if obj.is_a? Date or obj.is_a? Time or obj.is_a? DateTime
+        obj.to_datetime
+      elsif obj.is_a? String
+        DateTime.parse(obj)
+        # unless s
+        #   s = DateTime.strptime(obj, "%F %T %z")
+        # end
+        # unless s
+        #   s = DateTime.strptime(obj, "%FT%s%z")
+        # end
+        # s
+      else
+        DateTime.new(0)
+      end      
+    end
+
+    # Find all calculations in the current directory 
+    # with a given status
+    def Calculation.find_all(status)
+      # Catch all root calculations
+      calculations = Dir.glob File.join(AimsProject::CALCULATION_DIR, "*", AimsProject::CALC_STATUS_FILENAME)
+      # Catch all sub calculations
+      calculations << Dir.glob(File.join(AimsProject::CALCULATION_DIR, "*", "*",  AimsProject::CALC_STATUS_FILENAME))
+      calculations.collect{|calc_status_file|
+        calc_dir = File.dirname(calc_status_file)
+        calc = Calculation.load(calc_dir)
+        if (status == calc.status)
+          calc
+        else
+          nil
+        end
+      }.compact
+    end
+    
+    # Load a calculation from the serialized yaml file in the given directory
+    # raises an *ObjectFileNotFoundException* if the specified directory does
+    # not contain a yaml serialization of the calculation.
+    # raises a *CorruptObjectFileException* if the yaml file cannot be de-serialized
+    def Calculation.load(dir)
+      
+      calc_file  = File.join(dir, AimsProject::CALC_STATUS_FILENAME)
+      raise ObjectFileNotFoundException.new(calc_file) unless File.exists?(calc_file)
+      
+      f = File.open(calc_file, 'r')
+      calc_obj = YAML.load(f)
+      f.close
+      
+      raise CorruptObjectFileException.new(calc_file) unless calc_obj
+      return calc_obj
+    end
+    
+    # Create a calculation and the corresponding
+    # directory structure given a geometry and a control 
+    # This method will search for the files geometry.#{geometry}.in
+    # and control.#{control}.in in the project directory, then
+    # create a calculation directory that is the merger of those two
+    # filenames, and finally copy the geometry and control files into
+    # the calculation directory and rename them geometry.in and control.in
+    # @param [String] geometry The filename of the geometry file to use to initialize the calculation
+    # @param [String] control The filename of the control file to use to initialize the calculation
+    # @param [Hash<Symbol, Object>] user_vars A symbol=>Object hash of variables that will be available when 
+    #                     evaluating the geometry and control files using embedded ruby  
+    #                     This hash is also used to generate a calculation subdirectory
+    def Calculation.create(project, geometry, control, user_vars = {})
+
+      calc = Calculation.new(geometry, control)
+      calc.created_at = Time.new
+
+      control_in = calc.control_file
+      geometry_in = calc.geometry_file
+
+      # Define the calculation sub-directory if user_vars exists
+      unless user_vars.empty?
+        calc.calc_subdir = user_vars.keys.collect{|k| (k.to_s + "=" + user_vars[k].to_s).gsub('@', '').gsub(' ','_') }.join("..")
+      end
+      
+      # Add configuration variables to the calculation binding
+      uvars_file = File.join(AimsProject::CONFIG_DIR, "user_variables.rb")
+      calc.get_binding.eval(File.read(uvars_file)) if File.exists?(uvars_file)
+
+      # Merge project variables into calcuation binding
+      if project
+        project.instance_variables.each{|v|
+          if v == :@name # Ignore the project name
+            calc.instance_variable_set(:@project_name, project.instance_variable_get(v))
+          else
+            calc.instance_variable_set(v, project.instance_variable_get(v))
+          end
+        }
+      end
+
+      # Merge user-vars to the calculation binding
+      user_vars.each_pair{|sym, val|
+        calc.instance_variable_set(sym, val)
+      }
+      
+
+      # Check file existence
+      raise "Unable to locate #{control_in}" unless File.exists?(control_in) 
+      raise "Unable to locate #{geometry_in}" unless File.exists?(geometry_in)
+
+      # Validate the files
+      raise "#{geometry_in} has changed since last use" unless check_version(geometry_in)
+      raise "#{control_in} has changed since last use" unless check_version(control_in)
+
+      # Validate that the directory doesn't already exist
+      if Dir.exists? calc.calculation_directory
+        raise "Could not create calculation.\n #{calc.calculation_directory} already exists. \n\n If you really want to re-create this calculation, then manually delete it and try again. \n"
+      end
+      FileUtils.mkdir_p calc.calculation_directory
+      
+      erb = ERB.new(File.read(control_in))
+      File.open File.join(calc.calculation_directory, "control.in"), "w" do |f|
+        f.puts erb.result(calc.get_binding)
+      end
+      
+      erb = ERB.new(File.read(geometry_in))
+      File.open File.join(calc.calculation_directory, "geometry.in"), "w" do |f|
+        f.puts erb.result(calc.get_binding)
+      end
+
+
+      calc.status = AimsProject::STAGED
+      calc.save
+      
+      return calc
+    end
+    
+    # Get the binding for this calculation
+    def get_binding
+      binding()
+    end
+    
+    # The name of this calculation
+    def name
+      "#{geometry}.#{control}"
+    end
+    
+    # Intended to replace @geometry, but needs lots of regression testing
+    # for now, will just generate this on the fly
+    def input_geometry
+      unless @actual_geometry
+        @input_geometry = Aims::GeometryParser.parse(File.join(self.calculation_directory, "geometry.in"))
+      end
+      @input_geometry
+    end
+    
+    # Set the status to HOLD.
+    # Only possible if status is currently STAGED
+    def hold
+      if STAGED == status
+        self.status = HOLD
+        save
+        return true
+      else
+        return false
+      end
+    end
+    
+    # Set the status to STAGED if current status is HOLD
+    def release
+      if HOLD == status
+        self.status = STAGED
+        save
+        return true
+      else
+        return false
+      end
+    end
+    
+    # Create a new calculation that will restart a geometry relaxation 
+    # calculation using the last available geometry.  
+    # This method will generate a new file in 
+    # the geometry directory with the extension +restartN+, where 
+    # N will be incremented if the filename already exists.
+    # A new calculation will be created with the new geometry and 
+    # the original control.  
+    def restart_relaxation
+      
+      # Create a new geometry file
+      geometry_orig = self.geometry_file
+      
+      # Append the subdirectory if a subdir
+      if @calc_subdir
+        geometry_orig = geometry_orig + ".#{calc_subdir}"
+      end
+      
+      # If restarting a restart, then increment the digit
+      if (geometry_orig.split(".").last =~ /restart(\d+)/)
+        n = $1.to_i
+        geometry_orig = geometry_orig.split(".")[0...-1].join(".")
+      else
+        n = 0
+      end
+
+      begin 
+        n += 1
+        geometry_new = geometry_orig + ".restart#{n}"
+      end while File.exist?(geometry_new)
+      
+      File.open(geometry_new, 'w') do |f|
+        f.puts "# Final geometry from #{calculation_directory}"
+        f.puts self.geometry_next_step.format_geometry_in
+      end
+      
+      Calculation.create(nil, geometry_new, self.control)
+      
+    end
+    
+    # Initialize a new calculation.  Consider using Calculation#create 
+    # to generate the directory structure as well.
+    # @param [String] geometry the filename of the input geometry
+    # @param [String] control the filename of the input control 
+    def initialize(geometry, control)
+      self.geometry = File.basename(geometry)
+      self.control = File.basename(control)
+      self.history = Array.new
+    end
+
+    # Serialize this calculation as a yaml file
+    def save(dir = nil)
+      self.updated_at = Time.new
+      dir = calculation_directory unless dir
+      File.open(File.join(dir, AimsProject::CALC_STATUS_FILENAME), 'w') do |f|
+        f.puts YAML.dump(self)
+      end
+    end
+    
+    # Reload this calculation from the serialized YAML file
+    def reload
+      c = Calculation.load(self.calculation_directory)
+      self.geometry = c.geometry
+      @input_geometry = c.input_geometry
+      self.control = c.control
+      self.status = c.status
+      return self
+    end
+
+    # Determine the name of the control.in file from the
+    # control variable.  
+    def control_file
+      File.join(AimsProject::CONTROL_DIR, self.control)
+    end
+
+    # Determine the name of the geometr.in file from the 
+    # geometry variable
+    def geometry_file
+      File.join(AimsProject::GEOMETRY_DIR, self.geometry)
+    end
+
+    # 
+    # Check for the existence of a cached version of the input file
+    # If it exists, check if the cached version is the same
+    # as the working version, and return true if they are, false if they are not.
+    # If the cached version does not exist, then cache the working version and return true.  
+    def Calculation.check_version(file)
+      cache_dir = ".input_cache"
+      unless File.exists? cache_dir
+        Dir.mkdir cache_dir
+        Dir.mkdir File.join(cache_dir, AimsProject::GEOMETRY_DIR)
+        Dir.mkdir File.join(cache_dir, AimsProject::CONTROL_DIR)
+      end
+      
+      return false unless File.exists?(file)
+      cache_version = File.join(cache_dir, file)
+      if File.exists?(cache_version)
+        return FileUtils.compare_file(file, cache_version)
+      else
+        FileUtils.cp_r file, cache_version
+        return true
+      end
+
+    end
+
+    # The path of this calculation relative to the project
+    def relative_path
+      calculation_directory
+    end
+    
+    # 
+    # Return the directory for this calculation
+    #
+    def calculation_directory
+      File.join AimsProject::CALCULATION_DIR, self.name, (@calc_subdir || "")
+    end
+
+    def load_output(output_pattern = "*output*")
+      output_files = Dir.glob(File.join(calculation_directory, output_pattern))
+      if output_files.empty?
+        @output = nil
+      else
+        @output = Aims::OutputParser.parse(output_files.last)
+      end      
+    end
+
+    # Search the calculation directory for the calculation output.
+    # If found, parse it and return the Aims::AimsOutput object, otherwise
+    # return nil.
+    # If multiple output files are found, use the last one in the list
+    # when sorted alpha-numerically.  (This is assumed to be the most recent calculation)
+    def output(output_pattern = "*output*")
+      unless @output
+        load_output(output_pattern)
+      end
+      @output
+    end
+
+    # Parse the calculation output and return the final geometry
+    # of this calculation.  Return nil if no output is found.
+    def final_geometry
+      # ouput is not cached, so we only retrieve it once
+      o = self.output
+      if o
+        o.final_geometry
+      else
+        nil
+      end
+    end
+    
+    # Parse the geometry.in.next_step file in the calculation directory
+    # if it exists and return the Aims::Geometry object or nil
+    def geometry_next_step
+      g_file = File.join(calculation_directory, "geometry.in.next_step")
+      if File.exists?(g_file)
+        Aims::GeometryParser.parse(g_file)
+      else
+        nil
+      end
+    end
+    
+    # Return whether this calculation is converged or not
+    def converged?
+      if output.nil?
+        false
+      else
+        output.geometry_converged
+      end
+    end
+    
+  end
+end

data/lib/aims_project/calculation_tree.rb

@@ -0,0 +1,65 @@
+module AimsProject
+
+class CalculationTree < Wx::ScrolledWindow
+  
+  include Wx
+    
+  attr_accessor :app, :treeControl
+  
+  def initialize(app, window)
+    super(window)
+    self.app = app
+    
+    init_tree
+    
+    sizer = BoxSizer.new(VERTICAL)
+    sizer.add(self.treeControl, 1, EXPAND | ALL, 5)
+
+    set_auto_layout(true)
+    set_sizer(sizer)
+  end
+  
+  def init_tree
+    @treeControl = Wx::TreeCtrl.new(self)
+    root = self.treeControl.add_root("-")
+  end
+  
+  def show_calculation(calc)
+    @tree_map = {}
+    
+    @treeControl.delete_all_items
+    root = self.treeControl.add_root(calc.name)
+    input_geom = @treeControl.append_item(root, calc.geometry)
+    @tree_map[input_geom] = calc.input_geometry
+    @treeControl.append_item(root, calc.control)
+    @treeControl.append_item(root, calc.status)
+    @treeControl.append_item(root, "CONVERGED: #{calc.converged?}")
+    # @treeControl.append_item(root, calc.output.total_wall_time)
+    if calc.output
+      calc.output.geometry_steps.each{|step| 
+        step_id = @treeControl.append_item(root, "Step %i" % step.step_num)
+        @tree_map[step_id] = step
+        @treeControl.append_item(step_id, "Total Energy: %f" % step.total_energy)
+        @treeControl.append_item(step_id, "SC Iters: %i" % step.sc_iterations.size)
+        @treeControl.append_item(step_id, "Wall Time: %f" % step.total_wall_time.to_s)
+      }
+    end
+    @treeControl.expand(root)
+    # self.app.project.calculations.each{|calc|
+    #   calcid = self.treeControl.append_item(root, calc.name)
+    #   @tree_map[calcid] = calc
+    # }
+    
+    evt_tree_sel_changed(self.treeControl) {|evt|
+       item = @tree_map[evt.get_item]
+       if item.is_a? Aims::GeometryStep       
+         self.app.show_geometry(item.geometry)
+       end
+       if item.is_a? Aims::Geometry
+         self.app.show_geometry(item)
+       end
+    }
+  end
+  
+end
+end

data/lib/aims_project/calculation_window.rb

@@ -0,0 +1,141 @@
+module AimsProject
+
+  class CalculationWindow < Wx::Panel
+
+    include Wx
+    
+    CALC_TABLE_COLS=4
+    
+    def initialize(app, parent)
+      
+      super(parent)
+      @app = app
+      
+      # Initialize the selection
+      @selection = {}
+      
+      # The inspector window
+      @inspector_window = @app.inspector.add_inspector_window
+      
+      # Initialize the options for the crystal viewer
+      @options = CrystalViewerOptions.new(@inspector_window)
+      
+      # Top level is a splitter
+      topSplitterWindow = SplitterWindow.new(self)
+      sizer = VBoxSizer.new
+      sizer.add_item(topSplitterWindow, :proportion => 1, :flag => EXPAND)
+      
+      set_sizer(sizer)
+      
+      # The top is a list control
+      @calcTable = Grid.new(topSplitterWindow, -1)
+      init_table
+
+      # Populate the calculations list
+      @calcs = @app.project.calculations.sort{|a,b| a.name <=> b.name}
+      @calcs.each_with_index{|calc, i|
+        add_calc_at_row(calc, i)
+      }
+      @calcTable.auto_size
+
+      # The bottom is a vertical splitter
+      calcWindowSplitter = SplitterWindow.new(topSplitterWindow)
+      
+      # with a tree and a viewer
+      @calcTree = CalculationTree.new(self, calcWindowSplitter)
+      @calcViewer = CrystalViewer.new(self, calcWindowSplitter, @options)
+      calcWindowSplitter.split_vertically(@calcTree, @calcViewer)
+
+
+      # Split the top and bottom
+      topSplitterWindow.split_horizontally(@calcTable, calcWindowSplitter, 100)
+
+      # Setup the events
+      evt_grid_cmd_range_select(@calcTable) {|evt|
+        if evt.selecting
+          row = evt.get_top_row
+          puts "CalculationWindow.show_calculation #{@calcs[row].calculation_directory}"
+          show_calculation(@calcs[row])        
+        end
+      }
+      
+      evt_thread_callback {|evt|
+        @calcTree.show_calculation(@calculation)
+        if @calculation.final_geometry
+          show_geometry(@calculation.final_geometry)
+        else
+          show_geometry(@calculation.input_geometry)
+        end
+      }
+      
+    end
+    
+    def init_table
+      @calcTable.create_grid(@app.project.calculations.size, CALC_TABLE_COLS, Grid::GridSelectRows)
+      @calcTable.set_col_label_value(0, "Geometry")
+      @calcTable.set_col_label_value(1, "Subdirectory")
+      @calcTable.set_col_label_value(2, "Control")
+      @calcTable.set_col_label_value(3, "Status")
+      
+    end
+
+    # Insert a calculation in the table at the specified row
+    def add_calc_at_row(calc, row)
+      @calcTable.set_cell_value(row, 0, calc.geometry)
+      @calcTable.set_cell_value(row, 1, calc.calc_subdir.to_s)
+      @calcTable.set_cell_value(row, 2, calc.control)
+      @calcTable.set_cell_value(row, 3, calc.status)
+    end
+
+    def show_inspector
+      @app.inspector.show_inspector_window(@inspector_window)
+    end
+    
+    def show_calculation(calc)
+     begin
+       @calculation = calc
+       @err = nil
+       t = Thread.new(self) { |evtHandler|
+         begin
+           @app.set_status("Loading #{@calculation.name}")
+           @calculation.load_output
+           evt = ThreadCallbackEvent.new
+           evtHandler.add_pending_event(evt)
+           @app.set_status("")
+         rescue $! => e
+           @app.set_status(e.message)
+         end
+       }
+       t.priority = t.priority + 100
+     rescue $! => e
+       puts e.message
+       puts e.backtrace
+       @app.error_dialog(e)
+     end
+    end
+
+    # Get an Image
+    def image
+      @calcViewer.image
+    end
+
+    # get the currently displayed geometry
+    def geometry
+      @calcViewer.unit_cell
+    end
+
+    # Display the given geometry
+    def show_geometry(geometry)
+      @calcViewer.unit_cell = GeometryFile.new(geometry)
+    end
+    
+    def select_atom(atom)
+      @app.set_status(atom.format_geometry_in)
+    end
+    
+    def nudge_selected_atoms(x,y,z)
+      @app.error_dialog("Sorry, 'nudge' doesn't work on calculation outputs.")
+    end
+    
+  end
+end