aims_project 0.3.0

data/lib/aims_project/crystal_viewer_options.rb

@@ -0,0 +1,103 @@
+require 'observer'
+
+module AimsProject
+  class CrystalViewerOptions
+    
+    include Wx
+    include Observable  
+    
+      def add_control(name, control)
+        instance_variable_set("@#{name.to_s}".to_sym, control)
+        instance_eval <<-EOS
+          def #{name.to_s}
+            @#{name.to_s}.get_value
+          end
+
+          def #{name.to_s}=(val)
+            @#{name.to_s}.set_value(val)
+            changed
+            notify_observers
+          end
+        EOS
+        control
+      end
+
+  
+    def initialize(inspector_window)
+      
+      # Default padding around each element
+      border = 5
+
+      # Main Sizer
+      inspector_window.sizer = VBoxSizer.new
+
+      # Panel 1
+      panel1 =  VBoxSizer.new
+      panel1.add_item(add_control(:show_bonds,  CheckBox.new(inspector_window, :label => 'Show Bonds')), :flag => ALL,:border => border)
+      panel1.add_item(add_control(:show_lighting, CheckBox.new(inspector_window, :label => 'Show Lighting')), :flag => ALL, :border => border)
+      panel1.add_item(add_control(:show_supercell, CheckBox.new(inspector_window, :label => "Show Unit Cell")), :flag => ALL, :border => border)
+      panel1.add_item(add_control(:correct, CheckBox.new(inspector_window, :label => "Correct Geometry")), :flag => ALL, :border => border)
+      panel1.add_item(add_control(:solid_bg, CheckBox.new(inspector_window, :label => "Solid BG")), :flag => ALL, :border => border)
+      
+      gsizer = GridSizer.new(2,1)
+      gsizer.add(StaticText.new(inspector_window, :label => "Bond Length"))
+      gsizer.add_item(add_control(:bond_length, SpinCtrl.new(inspector_window, :min => 1, :max => 100, :value => "4", :name => "Name")), :flag => EXPAND)
+      panel1.add_item(gsizer)
+      
+      
+      # Panel 2 : Clip Planes
+      panel2 =  VBoxSizer.new
+      panel2.add_item(StaticText.new(inspector_window, -1, "Clip Planes:", :style => ALIGN_LEFT))
+      panel2.add_item(add_control(:show_xclip, CheckBox.new(inspector_window, :label => 'x')), :flag => Wx::ALIGN_CENTER, :border => border)
+      panel2.add_item(add_control(:show_yclip, CheckBox.new(inspector_window, :label => 'y')), :flag => Wx::ALIGN_CENTER, :border => border)
+      panel2.add_item(add_control(:show_zclip, CheckBox.new(inspector_window, :label => 'z')), :flag => Wx::ALIGN_CENTER, :border => border)
+      
+       # Panel 3: Repeat
+       panel3 = VBoxSizer.new
+       panel3.add_item(StaticText.new(inspector_window, -1, "Repeat:", :style => ALIGN_LEFT), :flag => EXPAND)
+      
+       panel3grid = GridSizer.new(3,2, border, border)
+       panel3grid.add(StaticText.new(inspector_window, :label => "x", :style => ALIGN_RIGHT),1, EXPAND)
+       panel3grid.add(add_control(:x_repeat, SpinCtrl.new(inspector_window, :value => "1", :min => 1, :max => 100, :initial => 1)),2)
+      
+       panel3grid.add(StaticText.new(inspector_window, :label => "y",:style => ALIGN_RIGHT),1, EXPAND)
+       panel3grid.add(add_control(:y_repeat, SpinCtrl.new(inspector_window, :value => "1", :min => 1, :max => 100, :initial => 1)),2)
+      
+       panel3grid.add(StaticText.new(inspector_window, :label => "z",:style => ALIGN_RIGHT),1, EXPAND)
+       panel3grid.add(add_control(:z_repeat, SpinCtrl.new(inspector_window, :value => "1", :min => 1, :max => 100, :initial => 1)),2)
+             
+       panel3.add_item(panel3grid, :flag => EXPAND | ALIGN_CENTER)
+
+       # Event Handling
+       inspector_window.evt_checkbox(@show_bonds) {|evt| changed; notify_observers}
+       inspector_window.evt_checkbox(@show_lighting) {|evt| changed; notify_observers}
+       inspector_window.evt_checkbox(@show_supercell) {|evt| changed; notify_observers}
+       inspector_window.evt_checkbox(@solid_bg) {|evt| changed; notify_observers}
+       inspector_window.evt_checkbox(@correct) {|evt| changed; notify_observers }
+       inspector_window.evt_spinctrl(@bond_length) {|evt| changed; notify_observers }
+       inspector_window.evt_checkbox(@show_xclip) {|evt| changed; notify_observers}
+       inspector_window.evt_checkbox(@show_yclip) {|evt| changed; notify_observers}
+       inspector_window.evt_checkbox(@show_zclip) {|evt| changed; notify_observers}
+       inspector_window.evt_spinctrl(@x_repeat) {|evt| changed; notify_observers}
+       inspector_window.evt_spinctrl(@y_repeat) {|evt| changed; notify_observers}
+       inspector_window.evt_spinctrl(@z_repeat) {|evt| changed; notify_observers}
+
+       # Add sub-panels
+       inspector_window.sizer.add_item(panel1, :flag => EXPAND, :proportion => 1)
+       inspector_window.sizer.add_spacer(5)
+       inspector_window.sizer.add_item(panel2, :flag => EXPAND, :proportion => 1)
+       inspector_window.sizer.add_spacer(5)
+       inspector_window.sizer.add_item(panel3, :flag => EXPAND, :proportion => 1)
+       inspector_window.layout
+    end
+      
+      def set_properties(props)
+        props.each{|k,v|
+          instance_variable_get("@#{k.to_s}").set_value(v)
+        }
+        changed
+        notify_observers
+      end
+
+  end
+end

data/lib/aims_project/geometry_editor.rb

@@ -0,0 +1,111 @@
+module AimsProject
+
+class GeometryEditor < Wx::ScrolledWindow
+  
+  include Wx
+  attr_accessor :app, :text_ctrl, :button_panel
+
+  @atom_ranges = {}
+
+  def initialize(app, window)
+    
+    super(window)
+
+    @app = app
+    
+    sizer = BoxSizer.new(VERTICAL)
+
+    @text_ctrl = StyledTextCtrl.new(self)
+    # @text_ctrl.set_sel_background(true, Colour.new("wheat"))
+    
+    # Create the button panel (A toolbar for the top of this panel)
+    @button_panel = HBoxSizer.new
+    
+    @toggle_source = CheckBox.new(self, ID_ANY, "Source")
+    
+    basedir = File.dirname(__FILE__)
+    arrow_icon = Image.new(File.join(basedir,"green_arrow.jpg"), BITMAP_TYPE_JPEG)
+    @eval_button = BitmapButton.new(self, :bitmap => arrow_icon.rescale(16,15).convert_to_bitmap,:style=>BU_EXACTFIT, :name => "evaluate")
+    
+    # error_icon = Image.new(File.join(basedir, "red_cross.jpeg"), BITMAP_TYPE_JPEG)
+    # @clear_errors_button = BitmapButton.new(self, :bitmap => error_icon.rescale(16,15).convert_to_bitmap,:style=>BU_EXACTFIT, :name => "Clear Errors")
+    
+    @button_panel.add_item(@toggle_source,1)
+    @button_panel.add_stretch_spacer
+    @button_panel.add_item(@eval_button,3)
+    
+    evt_checkbox(@toggle_source) {|evt|
+      if @toggle_source.is_checked
+        @text_ctrl.set_read_only(false)
+        @text_ctrl.set_text(@unit_cell.raw_input)
+      else
+        @text_ctrl.set_read_only(false)
+        @text_ctrl.set_text(@unit_cell.input_geometry)
+        @text_ctrl.set_read_only(true)
+      end
+    }
+    
+    sizer.add_item(@button_panel, :flag => EXPAND)
+    sizer.add_item(@text_ctrl, :proportion => 1, :flag => EXPAND | ALL, :border => 5)
+
+    set_auto_layout(true)
+    set_sizer(sizer)
+
+        
+    evt_button(@eval_button) {|event|
+        self.evaluate
+    }
+
+  end
+  
+  # Apply the edits to the geometry_file and evaluate
+  def evaluate
+    @unit_cell.raw_input = @text_ctrl.get_text
+    begin
+      @unit_cell.evaluate    
+    rescue 
+      # @button_pane.add_item(@clear_errors_button, 3)
+      @text_ctrl.set_text($!.message + $!.backtrace.join("\n"))
+    end
+  end
+  
+  def unit_cell=(uc)
+    @unit_cell = uc
+    if @toggle_source.is_checked
+      @text_ctrl.set_read_only(false)
+      @text_ctrl.set_text(@unit_cell.raw_input)
+      @text_ctrl.set_read_only(false)
+      
+    else
+      @text_ctrl.set_read_only(false)
+      @text_ctrl.set_text(@unit_cell.input_geometry)
+      @text_ctrl.set_read_only(true)
+      
+    end
+  end
+  
+  def select_atom(atom)
+    selectionStyle = Wx::RichTextAttr.new(Wx::BLACK, Wx::Colour.new("YELLOW"))
+    
+    pattern = atom.format_geometry_in
+    puts "GeometryEditor.select_atom: pattern=#{pattern}"
+
+    matchdata = self.text_ctrl.get_text.match(pattern)
+    if matchdata
+      lineStart = matchdata.begin(0)
+      lineEnd = matchdata.end(0)
+      # self.text_ctrl.set_style(lineStart...lineEnd, selectionStyle)
+      self.text_ctrl.goto_pos(lineStart)
+      self.text_ctrl.set_selection_start(lineStart)
+      self.text_ctrl.set_selection_end(lineEnd)
+    end
+  end
+  
+  
+  # Return the text contents of this control
+  # after evaluating it with ERB
+  def get_contents
+    ERB.new(@text_ctrl.get_value).result
+  end
+end
+end

data/lib/aims_project/geometry_file.rb

@@ -0,0 +1,184 @@
+require 'erb'
+require 'observer'
+
+module AimsProject
+  # The geometry model utilized by this application
+  class GeometryFile 
+  
+    include Observable
+    
+    # Include Aims here to ensure that ERB will evaluate ruby
+    # without prefixing Aims:: when using the builtin binding.
+    include Aims
+  
+    # Read and parse a geometry file.  Use the given binding to 
+    # evaluate any embedded ruby
+    def GeometryFile.eval_geometry(str, _binding=nil)
+
+      b = if _binding
+        _binding
+      else
+        binding()
+      end
+
+      erb = ERB.new(str)
+      erb.result(b)
+
+    end
+  
+    # The filename of the geometry file
+    attr_reader :file
+    
+    # The Aims::Geometry object
+    attr_reader :aims_geometry
+    
+    # The string representation of the parsed input geometry
+    attr_reader :input_geometry
+    
+    # The raw unevaluated input.
+    attr_reader :raw_input
+
+    # Parse a geometry input 
+    # Evaluate any embedded ruby using the given binding
+    # @param input If input is a File, the file is read and evaluated with ERB
+    #             If input is a String, the input is directly evaluated with ERB
+    # @param _binding The binding to use when evaluating with EB
+    def initialize(input, _binding=nil)
+      
+      if input.respond_to? :read
+        @file = input
+        @raw_input = @file.read
+      elsif input.is_a? String
+        @raw_input = input
+      elsif input.is_a? Aims::Geometry
+        @aims_geometry = input
+        @input_geometry = @aims_geometry.format_geometry_in
+        @raw_input = @input_geometry
+      end
+      
+      begin
+        # Attempt to evaluate the raw input, but don't require it.
+        @binding = _binding
+        evaluate(@binding)
+      rescue
+      end
+    end
+    
+    # Set the raw input
+    # @param str The string to set the raw input to
+    # @param notify Whether or not to notify observer. Set this to false if you intend to call evaluate immediately after
+    def raw_input=(str, notify = true)
+      @raw_input = str
+      if notify
+        changed
+        notify_observers
+      end
+    end
+    
+    # Evaluate the raw input and return a geometry String formatted in the Aims geometry.in format
+    # 
+    def evaluate(_binding=nil)
+      if _binding
+        @binding = _binding
+      end
+      
+      @input_geometry = GeometryFile.eval_geometry(@raw_input, @binding)
+      @aims_geometry = GeometryParser.parse_string(@input_geometry) 
+      
+      changed
+      notify_observers
+      
+      @aims_geometry
+    end
+    
+    # Delegate calls to the Aims::Geometry object if it exists.
+    def method_missing(symbol, *args, &block)
+      if @aims_geometry.nil?
+        raise GeometryEvaluationException.new
+      else
+        @aims_geometry.send(symbol, *args, &block)
+      end
+    end
+    
+    # Check the consistency between the raw, the evaluated and the object-space geometries
+    def is_valid?
+      begin
+        validate
+        return true
+      rescue GeometryValidationException => e
+        return false
+      end
+    end
+      
+    # Check the consistency of all internal data models
+    # @return true, otherwise raises a GeoemtryValidationException
+      def validate
+        # The raw input evaluated must match the input_geometry
+        erb = ERB.new(@raw_input)
+        res = erb.result(@binding)
+        unless  res == @input_geometry
+          raise GeometryValidationException.new("raw input doesn't match evaluated input")
+        end
+      
+        # Also need to somehow validate against the Aims::Geometry
+        g = GeometryParser.parse_string(res)
+        unless g.atoms.size == @aims_geometry.atoms.size
+          raise GeometryValidationException("input geometry atom count doesn't match aims_geometry")
+        end
+        
+        unless g.lattice_vectors.size == @aims_geometry.lattice_vectors.size
+          raise GeometryValidationException("input geometry lattice vector count doesn't match aims_geometry")
+        end
+      
+        g.atoms.each{|a| 
+          unless @aims_geometry.atoms.member?(a)
+            raise GeometryValidationException("atom mismatch")
+          end
+        }
+        
+        g.lattice_vectors.each{|v| 
+          unless @aims_geometry.lattice_vectors.member?(v)
+            raise GeometryValidationException("lattice vector mismatch")
+          end
+        }
+
+        return true
+    end
+    
+    # Save this geometry 
+    # raises an InvalidFilenameException unless @file is not nil
+    # @return  self
+    def save
+      save_as(@file)
+    end
+        
+    # Save the raw input to file if it passes validation
+    # raises an InvalidFilenameException unless @file is not nil
+    # raises a GeometryValidationException if it fails to pass Validation
+    # @return A new GeometryFile object representing the geometry in the newly created file
+    #         or this GeometryFile object if file = nil
+    def save_as(file)
+
+        if file.nil?
+          raise InvalidFilenameException(nil) unless @file
+          file = @file
+        end
+        
+        # validate
+        
+        File.open(file, 'w') {|f|
+          f.write @raw_input
+        }
+        
+        if file == @file
+          return self
+        else
+          GeometryFile.new(File.new(file.path, "r"))
+        end
+        
+    end
+    
+  end
+  
+  
+end

data/lib/aims_project/geometry_window.rb

@@ -0,0 +1,172 @@
+module AimsProject
+
+  class GeometryWindow < Wx::Panel
+
+    include Wx
+    
+    attr_accessor :update_unit_cell
+    
+    def initialize(app, parent)
+      
+      super(parent)
+      @app = app
+            
+      # Initialize the selection of atoms
+      @selection = {}
+      
+      # Tracks whether changes in inspector should update the unit cell
+      @update_unit_cell = false
+      
+      # Get an inspector window to add into
+      @inspector_window = @app.inspector.add_inspector_window
+      
+      # This is a model/controller for the inspector to pass to 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
+      @geomList = ListCtrl.new(topSplitterWindow)
+      app.project.geometries.sort{|a,b| a <=> b}.each{|geom|
+        li = ListItem.new
+        li.set_text(File.basename(geom))
+        li.set_data(geom)
+        @geomList.insert_item(li)
+      }
+      
+      # The bottom is a vertical splitter
+      geomWindowSplitter = SplitterWindow.new(topSplitterWindow)
+      @geomEditor = GeometryEditor.new(self, geomWindowSplitter)
+      @geomViewer = CrystalViewer.new(self, geomWindowSplitter, @options)
+      
+      geomWindowSplitter.split_vertically(@geomEditor, @geomViewer)
+      
+      # Add top and bottom sides together
+      topSplitterWindow.split_horizontally(@geomList, geomWindowSplitter, 100)
+      layout
+      
+      # Define events
+      evt_list_item_selected(@geomList) {|evt|
+        open_geometry_file(evt.get_item.get_data)
+      }
+      
+      
+    end
+    
+    # Add a geometry with the given name
+    def add_geometry(geometry)
+      @app.project.geometries << geometry
+      li = ListItem.new
+      li.set_text(File.basename(geometry.file))
+      li.set_data(geometry.file)
+      li.set_state(LIST_STATE_SELECTED)
+      @geomList.insert_item(li)
+      @geomList.sort{|a,b| a <=> b}
+    end
+    
+
+    def show_inspector
+      @app.inspector.show_inspector_window(@inspector_window)
+    end
+    
+    # Display a file dialog and attempt to open and display the file
+    def open_geometry_file(file = nil)
+      begin
+        unless file
+          fd = FileDialog.new(@app.frame, :message => "Open", :style => FD_OPEN, :default_dir => @working_dir)
+          if ID_OK == fd.show_modal
+            file = fd.get_path
+            @working_dir = fd.get_directory
+          else
+            return
+          end
+        end
+        @app.set_status "Opening #{file}"
+
+        if (@app.project)
+          show_geometry GeometryFile.new(File.new(file), @app.project.get_binding)
+        else
+          show_geometry GeometryFile.new(File.new(file))
+        end
+
+
+      rescue Exception => dang
+        @app.error_dialog(dang)
+      end
+    end
+    
+    def image
+      @geomViewer.image
+    end
+    
+    # Get the currently displayed geometry
+    def geometry
+      @original_uc
+    end
+    
+    # Display the given geometry
+    def show_geometry(geometry)
+      begin
+        @original_uc = geometry
+        @geomViewer.unit_cell = @original_uc
+      rescue AimsProjectException => e
+        @app.error_dialog(e)
+      ensure
+        @geomEditor.unit_cell = @original_uc
+      end
+      # @inspector.update(@geomViewer)
+      # @geomViewer.draw_scene
+    end
+    
+    def select_atom(atom)
+      @selection[:atoms] = [atom]
+      puts "Selection:" 
+      puts @selection[:atoms].each{|a| puts a.format_geometry_in}
+      @geomEditor.select_atom(atom)
+    end
+    
+    def nudge_selected_atoms(x,y,z)
+      if @selection[:atoms]
+        @selection[:atoms].each{|a| a.displace!(x,y,z)}
+      end
+      @geomViewer.draw_scene
+      @geomEditor.update
+    end
+    
+    # Apply UI settings to viewer and re-render
+    def update_viewer
+      
+      puts "GeometryWindow.update_viewer"
+
+      if @original_uc and self.update_unit_cell
+        if @correct.get_value
+          # @geomViewer.unit_cell = @original_uc.correct
+          new_geom = @original_uc.repeat(@x_repeat.get_value, @y_repeat.get_value, @z_repeat.get_value).correct
+        else
+          # @geomViewer.unit_cell = @original_uc
+          new_geom = @original_uc.repeat(@x_repeat.get_value, @y_repeat.get_value, @z_repeat.get_value)
+        end
+        @geomViewer.unit_cell = new_geom
+        @geomEditor.unit_cell = new_geom
+        self.update_unit_cell = false
+      end
+
+      # @geomViewer.repeat = [@inspector.x_repeat, @inspector.y_repeat, @inspector.z_repeat]
+      @geomViewer.show_bonds = @show_bonds.get_value
+      @geomViewer.bond_length = @bond_length.get_value
+      @geomViewer.lighting = @show_lighting.get_value
+      @geomViewer.show_supercell = @show_cell.get_value
+      @geomViewer.show_xclip = @show_xclip.get_value
+      @geomViewer.show_yclip = @show_yclip.get_value
+      @geomViewer.show_zclip = @show_zclip.get_value
+      @geomViewer.background.alpha = ((@transparent_bg.get_value) ? 0 : 1)
+      @geomViewer.draw_scene
+    end
+    
+  end
+end