aims_project_windows 0.3.1

data/lib/aims_project/inspector.rb

@@ -0,0 +1,183 @@
+module AimsProject
+class Inspector < Wx::Frame
+
+  include Wx
+
+  class << self
+    def control_value_accessor(*args)
+      args.each do |cb|
+        class_eval <<-EOS
+        def #{cb.to_s}
+          @#{cb.to_s}.get_value
+        end
+EOS
+      end
+    end
+  end
+
+  control_value_accessor :bond_length
+  control_value_accessor :show_bonds, :show_lighting, :show_cell
+  control_value_accessor :show_clip_planes, :show_xclip, :show_yclip, :show_zclip
+  control_value_accessor :x_repeat, :y_repeat, :z_repeat
+  control_value_accessor :correct
+  control_value_accessor :transparent_bg
+  
+  attr_accessor :update_unit_cell
+  
+  def initialize(app, frame)
+    
+    super(frame, :style => (CLOSE_BOX | CAPTION | FRAME_FLOAT_ON_PARENT))
+
+    @app = app
+    
+    # Array to track the inspector windows being shown
+    @windows = []
+    
+    self.sizer = BoxSizer.new(VERTICAL)
+    set_auto_layout(true)
+    self.sizer.set_size_hints(self)
+    self.sizer.fit(self)
+
+    self.update_unit_cell = false
+    self.evt_close {|event| self.hide }
+  end
+   
+   # Create a window to show in the inspector. Default is to not show this window.
+   # call show_inspector_window() to show it
+   # options are Wx:Sizer options
+   # return the window so that caller can add controls to it
+   def add_inspector_window(options = {})
+     window = Panel.new(self)
+     @windows << window
+     self.sizer.add_item(window, options)
+     self.sizer.show(window, false)
+     return window
+   end
+   
+   # Show the inspector window
+   def show_inspector_window(window)
+     @windows.each {|w|
+         self.sizer.show(w, w == window)
+      }
+      self.sizer.fit(self)
+   end
+   
+   # The view options
+   def view_options_panel(parent)
+
+     # Default padding around each element
+     border = 5
+     
+     panel = Wx::VBoxSizer.new
+     parent.sizer = panel
+      
+     # Panel 1
+     panel1 =  Wx::VBoxSizer.new
+
+     @show_bonds = Wx::CheckBox.new(parent, :label => 'Show Bonds')
+     panel1.add_item(@show_bonds, :flag => ALL,:border => border)
+     
+     @show_lighting = Wx::CheckBox.new(parent, :label => 'Show Lighting')
+     panel1.add_item(@show_lighting, :flag => ALL, :border => border)
+
+     @show_cell = Wx::CheckBox.new(parent, :label => "Show Unit Cell")
+     panel1.add_item(@show_cell, :flag => ALL, :border => border)
+
+     @correct = Wx::CheckBox.new(parent, :label => "Correct Geometry")
+     panel1.add_item(@correct, :flag => ALL, :border => border)
+
+     @transparent_bg = Wx::CheckBox.new(parent, :label => "Transparent BG")
+     panel1.add_item(@transparent_bg, :flag => ALL, :border => border)
+
+     gsizer = GridSizer.new(2,1)
+     gsizer.add(StaticText.new(parent, :label => "Bond Length"))
+     @bond_length = SpinCtrl.new(parent, :min => 1, :max => 100, :value => "4")
+     gsizer.add_item(@bond_length, :flag => EXPAND)
+     panel1.add_item(gsizer)
+
+     evt_checkbox(@show_bonds) {|evt| @app.update_viewer}
+     evt_checkbox(@show_lighting) {|evt| @app.update_viewer}
+     evt_checkbox(@show_cell) {|evt| @app.update_viewer}
+     evt_checkbox(@transparent_bg) {|evt| @app.update_viewer}
+     evt_checkbox(@correct) {|evt| 
+        self.update_unit_cell = true
+        @app.update_viewer
+      }
+     evt_spinctrl(@bond_length) {|evt| @app.update_viewer }
+     
+     # Panel 2 : Clip Planes
+     panel2 =  Wx::VBoxSizer.new
+     panel2.add_item(StaticText.new(parent, -1, "Clip Planes:", :style => ALIGN_LEFT))
+     @show_xclip = Wx::CheckBox.new(parent, :label => 'x')
+     panel2.add_item(@show_xclip, 0, Wx::ALIGN_CENTER, border)
+     @show_yclip = Wx::CheckBox.new(parent, :label => 'y')
+     panel2.add_item(@show_yclip, 0, Wx::ALIGN_CENTER, border)
+     @show_zclip = Wx::CheckBox.new(parent, :label => 'z')
+     panel2.add_item(@show_zclip, 0, Wx::ALIGN_CENTER, border)
+     
+
+      evt_checkbox(@show_xclip) {|evt| @app.update_viewer}
+      evt_checkbox(@show_yclip) {|evt| @app.update_viewer}
+      evt_checkbox(@show_zclip) {|evt| @app.update_viewer}
+
+      # Panel 3: Repeat
+      panel3 = Wx::VBoxSizer.new
+      panel3.add_item(StaticText.new(parent, -1, "Repeat:", :style => ALIGN_LEFT), 0, EXPAND)
+
+      panel3grid = GridSizer.new(3,2, border, border)
+      
+      @x_repeat = Wx::SpinCtrl.new(parent, :value => "1", :min => 1, :max => 100, :initial => 1)
+      @y_repeat = Wx::SpinCtrl.new(parent, :value => "1", :min => 1, :max => 100, :initial => 1)
+      @z_repeat = Wx::SpinCtrl.new(parent, :value => "1", :min => 1, :max => 100, :initial => 1)
+
+      evt_spinctrl(@x_repeat) {|evt| 
+        self.update_unit_cell = true
+        @app.update_viewer
+      }
+      evt_spinctrl(@y_repeat) {|evt| 
+        self.update_unit_cell = true
+        @app.update_viewer
+      }
+      evt_spinctrl(@z_repeat) {|evt| 
+        self.update_unit_cell = true
+        @app.update_viewer
+      }
+
+      panel3grid.add(StaticText.new(parent, :label => "x", :style => ALIGN_RIGHT),1, EXPAND)
+      panel3grid.add(@x_repeat,2)
+      
+      panel3grid.add(StaticText.new(parent, :label => "y",:style => ALIGN_RIGHT),1, EXPAND)
+      panel3grid.add(@y_repeat,2)
+      
+      panel3grid.add(StaticText.new(parent, :label => "z",:style => ALIGN_RIGHT),1, EXPAND)
+      panel3grid.add(@z_repeat,2)
+      
+      panel3.add(panel3grid, 0, EXPAND | ALIGN_CENTER)
+      
+      # Add sub-panels
+      panel.add(panel1, 0, Wx::ALL)
+      panel.add_spacer(5)
+      panel.add(panel2, 0, Wx::EXPAND)
+      panel.add_spacer(5)
+      panel.add(panel3, 0, Wx::EXPAND)
+
+     
+   end
+   
+   # Called when a new file is loaded
+   def update(viewer)
+     @show_bonds.set_value(viewer.show_bonds)
+     @show_lighting.set_value(viewer.lighting)
+     @show_cell.set_value(viewer.show_supercell)
+     @correct.set_value(false)
+     @show_xclip.set_value(viewer.show_xclip)
+     @show_yclip.set_value(viewer.show_yclip)
+     @show_zclip.set_value(viewer.show_zclip)
+     @bond_length.set_value(viewer.bond_length)
+     @x_repeat.set_value(1)
+     @y_repeat.set_value(1)
+     @z_repeat.set_value(1)
+   end
+   
+end
+end

data/lib/aims_project/material.rb

@@ -0,0 +1,30 @@
+module AimsProject
+  class Material
+
+    include Gl
+
+    attr_accessor :r, :g, :b, :alpha
+
+    def Material.black
+      Material.new(0,0,0)
+    end
+
+    def initialize(r,g,b,alpha=1)
+      self.r = r
+      self.g = g
+      self.b = b
+      self.alpha = alpha
+    end
+
+    def apply(lighting = true)
+      if lighting
+        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, [self.r, self.g, self.b, self.alpha])
+        glMaterialfv(GL_FRONT, GL_SPECULAR, [self.r, self.g, self.b, self.alpha])
+        glMaterialf(GL_FRONT, GL_SHININESS, 50)
+      else
+        glColor3f(self.r, self.g, self.b)
+      end
+    end
+  end
+
+end

data/lib/aims_project/octree.rb

@@ -0,0 +1,5 @@
+module AimsProject
+  class Octree
+    
+  end
+end

data/lib/aims_project/project.rb

@@ -0,0 +1,102 @@
+require 'fileutils'
+
+module AimsProject
+  
+class Project
+
+      #  A project is a collection of calculations
+      #  and tools for managing the execution and analysis of the calculations
+
+      # The name of this project
+      attr_accessor :name
+
+      # Load a Project from the serialized yaml file
+      def Project.load(filename)
+        yamlfile = [filename, filename+".yaml"].find{|f| File.exists?(f)}
+        
+        File.open(yamlfile, 'r') do |f|
+          YAML.load(f)
+        end
+      end
+
+      # Create a new Project with the given name
+      # This will also create the directory structure 
+      # for the project.  Returns true if successful, false otherwise
+      def Project.create(name)
+        
+          return nil unless name
+          
+            p = Project.new(name)
+            
+            # Create the project directory
+            FileUtils.mkdir(p.relative_path)
+            p.save(p.relative_path)
+            # 
+            # # Create the config directory
+            # FileUtils.mkdir(File.join(p.relative_path, "config"))
+            # 
+            # # Create the geometry directory
+            # FileUtils.mkdir(File.join(p.relative_path, AimsProject::GEOMETRY_DIR))
+            # 
+            # # Create the control directory
+            # FileUtils.mkdir(File.join(p.relative_path, AimsProject::CONTROL_DIR))
+            # 
+            # # Create the calculations directory
+            # FileUtils.mkdir(File.join(p.relative_path, AimsProject::CALCULATION_DIR))
+
+            return p
+      end
+      
+      # Initialize a new project object with the given name.
+      # This does not create the project directory structure, use create for that.
+      def initialize(name)
+        self.name = name
+      end
+      
+      # Return the binding for this project
+      def get_binding
+        binding
+      end
+      
+      # The path of this project relative to project_root_dir
+      def relative_path
+        name
+      end
+      
+      # The filename of the serialized yaml file representing this project
+      def serialized_filename
+        "#{self.name}.yaml"
+      end
+      
+      # The full path to this project locally
+      def full_path
+        File.dirname(File.expand_path(serialized_filename))
+      end
+            
+      # Serialize this project to a yaml file named after this project
+      # in the given directory
+      def save(dir = ".")
+        File.open(File.join(dir, "#{name}.yaml"), 'w') do |f|
+          f.print YAML.dump(self)
+        end
+      end
+      
+      # Retreive the calcluations managed by this project.
+      # This array is loaded directly from serialized yaml
+      # files in each calculation directory
+      def calculations
+        calc_status_files = Dir.glob(File.join(AimsProject::CALCULATION_DIR, "*", AimsProject::CALC_STATUS_FILENAME))
+        # pick up sub-calculations
+        calc_status_files += Dir.glob(File.join(AimsProject::CALCULATION_DIR, "*", "*", AimsProject::CALC_STATUS_FILENAME))
+        calc_status_files.collect{|f|
+          Calculation.load(File.dirname(f))
+        }
+      end
+      
+      # Retreive the geometries managed by this project.
+      def geometries
+        Dir.glob(File.join(AimsProject::GEOMETRY_DIR, "*"))
+      end
+      
+end
+end

data/lib/aims_project/project_tree.rb

@@ -0,0 +1,62 @@
+module AimsProject
+
+class ProjectTree < Wx::ScrolledWindow
+  
+  include Wx
+  
+  ROOT = "Root"
+  GEOMETRY = "Geometry"
+  CONTROL = "Control"
+  CALCULATIONS = "Calculations"
+  
+  
+  attr_accessor :app, :treeControl
+  
+  def initialize(app, window)
+    super(window)
+    self.app = app
+    
+    init_project_tree
+    
+    sizer = BoxSizer.new(VERTICAL)
+    sizer.add(self.treeControl, 1, EXPAND | ALL, 5)
+
+    set_auto_layout(true)
+    set_sizer(sizer)
+  end
+  
+  def init_project_tree
+    @treeControl = Wx::TreeCtrl.new(self)
+    @tree_map = {}
+    if self.app.project
+      @tree_map[ROOT] = self.treeControl.add_root(self.app.project.name)
+      @tree_map[GEOMETRY] = self.treeControl.append_item(@tree_map[ROOT], GEOMETRY)
+      @tree_map[CONTROL] = self.treeControl.append_item(@tree_map[ROOT], CONTROL)
+      @tree_map[CALCULATIONS] = self.treeControl.append_item(@tree_map[ROOT], CALCULATIONS)
+
+      self.app.project.geometries.each{|geom|
+        self.treeControl.append_item(@tree_map[GEOMETRY], geom)
+      }
+
+      self.app.project.calculations.each{|calc|
+        calcid = self.treeControl.append_item(@tree_map[CALCULATIONS], calc.name)
+        @tree_map[calcid] = calc
+      }
+      
+      evt_tree_sel_changed(self.treeControl) {|evt|
+        itemid = evt.get_item
+        if @tree_map[GEOMETRY] == self.treeControl.get_item_parent(itemid)
+          self.app.open_file(self.treeControl.get_item_text(itemid))
+        elsif @tree_map[CALCULATIONS] == self.treeControl.get_item_parent(itemid)
+          calc = @tree_map[itemid]
+          self.app.show_calculation(calc)
+        end
+      }
+    else
+      @tree_map[ROOT] = self.treeControl.add_root(ROOT)
+    end
+    @treeControl.expand(@tree_map[ROOT])
+  end
+  
+end
+end

data/lib/aims_project/thread_callback_event.rb

@@ -0,0 +1,19 @@
+module AimsProject
+  class ThreadCallbackEvent < Wx::CommandEvent
+    
+    @@event_type_id = 0
+    
+    def ThreadCallbackEvent.set_event_type(id)
+      @@event_type_id = id
+    end
+    
+    def ThreadCallbackEvent.event_type
+      @@event_type_id
+    end
+    
+    def initialize
+      super(@@event_type_id)
+    end
+    
+    end
+end

data/lib/aims_project.rb

@@ -0,0 +1,158 @@
+
+# AimsProject is an application for visualizing and managing projects for
+# the FHI-AIMS package
+
+require "rubygems"
+require 'aims'
+require 'yaml'
+
+require 'aims_project/project.rb'
+require 'aims_project/calculation.rb'
+require 'aims_project/geometry_file.rb'
+require 'aims_project/aims_project_exception.rb'
+
+# AimsProject is a set of tools for managing and organizing 
+# calculations for executaion on high-performance computing clusters.
+# It is designed specifically for the FHI-AIMS package published
+# by the Fritz-Haber Institute (https://aimsclub.fhi-berlin.mpg.de), 
+# but can probably be generatlized to other codes.
+#
+# Author: Joshua Shapiro (email:joshua.shapiro@gmail.com)
+# Copyright: 2012 Joshua Shapiro
+# License: TBD
+#
+# = Why should I use AimsProject?
+# Good organization is crucial to obtaining meaningful results with
+# the FHI-AIMS package.  Careful testing of convergence 
+# across parameters in the control and geometry files easily requires
+# dozens of calculations.  The novice and expert user alike can quickly 
+# lose track of which calculations are complete, which are still pending,
+# which calculations were errors, and which calculations failed or were aborted.
+# In this framework, even the most experienced user can and will make mistakes.  
+#
+# <em>The aim of this tool is to simplify and streamline the calculation 
+# pipeline, so the user can focus on the results.</em>
+# 
+# = Features
+# * Automated generation of calculations from control & geometry files.
+# * Automated synchronization between a workstation and the compute cluster. 
+# * Automated job submission of pending calculations to the queue
+# * Status tracking of calculations from creation to completion.
+# * Simple organizational structure with human readable metadata. 
+#   
+# = Planned Features
+# * Input file validation (To catch mistakes before submitting to a queue)
+# * Geometry input and output visualization
+# 
+# = Quick Start
+# == Installation
+#
+#    gem install aims_project
+#
+# == Creating a Project
+#
+# Type:
+#       AimsProject myProject
+# 
+# This will create the directory structure
+#      myProject
+#       -> calculations/
+#       -> config/
+#       -> control/
+#       -> geometry/
+#       -> Capfile
+#       -> myProject.yaml
+#
+# 
+# +calculations+:: Contains one subdirectory for each calculation.
+# +config+:: Contains special configuration files for automation.
+# +geometry+:: This is where you will place all your geometry files.
+# +control+:: This is where you place all your control files.
+# +Capfile+:: Location where you customize the interaction with the compute cluster
+# +myProject.yaml+:: Human readable metadata related to this project.
+#
+# == Creating a calculation
+#
+# Assume you are investigating two atomic configurations _alpha_ and _beta_, and
+# you want to calculate them with the _light_ and _tight_ settings. 
+# 
+# Create the FHI-AIMS formatted input files and name them 
+# * +geometry/alpha+
+# * +geometry/beta+
+# * +control/light+
+# * +control/tight+
+#
+# Now run 
+#    > AimsCalc create alpha light
+#    > AimsCalc create beta light
+#    > AimsCalc create alpha tight
+#    > AimsCalc create beta tight
+#
+# This will create four subdirectories inside +calculations/+.
+#    > ls calculations/*
+#     calculations/alpha.light:
+#     calc_status.yaml   control.in       geometry.in
+#     
+#     calculations/alpha.tight:
+#     calc_status.yaml   control.in       geometry.in
+#     
+#     calculations/beta.light:
+#     calc_status.yaml   control.in       geometry.in
+#     
+#     calculations/beta.tight:
+#     calc_status.yaml   control.in       geometry.in
+#     
+# Notice that each calculation directory has the required +control.in+ and 
+# +geometry.in+ file.  These were directly copied from the geometry and control files
+# passed to AimsCalc.  *Note* It is possible to embed variables inside the control
+# and geometry files, see AimsCalc for more details. Each directory also contains
+# a file named +calc_status.yaml+.  This is a metadata file used for tracking
+# the history and status of the calculation.  Currently this file looks something like
+#    --- !ruby/object:AimsProject::Calculation 
+#    control: light
+#    geometry: alpha
+#    status: STAGED
+# 
+# 
+# Feel free to get more creative with the geometry and control file names.  You should encode
+# as much information in the file name as possible, as this will make it easy 
+# for you to identify the calculation later.  For example, a geometry file 
+# named +alpha2x2_5layers_relaxed+ and a control file named +light_tier1_norelax_6x6x1_lomem+
+# will result in a calulation directory named +alpha2x2_5layers_relaxed.light_tier1_norelax_6x6x1_lomem+
+#
+# == Running a Calculation
+# At this point the calculation status is +STAGED+.  To run the calculation, first customize
+# the +Capfile+ with details necessary for running FHI-AIMS on the computing cluster. 
+# Check this file carefully, this is where you define the name and location of the aims executable, 
+# the name of the server, and the method for submitting jobs to the queue.  Once this file 
+# is properly configured, the calculations are submitted with one line:
+# 
+#     cap aims:enqueue
+#
+# This command invokes custom tasks in +Capistrano+, a 3rd party tool for automated deployment, 
+# that will upload the calculations to the server and submit them to the queue.
+# 
+
+
+
+module AimsProject
+  # Constants
+  STAGED   = "STAGED"
+  HOLD     = "HOLD"
+  QUEUED   = "QUEUED"
+  RUNNING  = "RUNNING"
+  COMPLETE = "COMPLETE"
+  ABORTED  = "ABORTED"
+  CANCELED = "CANCELED"
+  
+  CONFIG_DIR = "config"
+  CALCULATION_DIR = "calculations"
+  GEOMETRY_DIR = "geometry"
+  CONTROL_DIR = "control"
+  CALC_STATUS_FILENAME = "calc_status.yaml"
+  PROJECT_VARIABLES_FILENAME = "project_vars.rb"
+  
+  GLOBAL_CONFIG_DIR = File.join(ENV["HOME"], ".aims_project")
+  GLOBAL_VARIABLES_FILENAME = "aims_project_vars.rb"
+
+end

data/skeleton/Capfile

@@ -0,0 +1,37 @@
+require 'aims_project'
+
+load 'config/tasks.rb'
+
+# The name of this project
+set :project_name, '__PROJECT_NAME__'
+
+# The following settings apply to calculations occuring on the remote host
+
+# The base directory on the remote host
+set :remote_project_dir, 'AimsProjects'
+
+# Query the user for the number of parallel nodes when queueing calculations
+set(:nodes) {Capistrano::CLI.ui.ask("How many compute nodes?: ")}
+
+# The memory for each calculation
+set :memory, 1024
+
+# The time limit for each calculation
+set :time, 24
+
+# Set the qstat command
+set :qstat_cmd, "qstat -u jns"
+
+# The qsub command to execute
+# There are some extra commands in here to forward SIGUSR1 and SIGUSR2 to aims_script
+# so that the job status can be properly updated if the job is aborted
+# aims_script is predefined to be 'aims.sh', if this is unsuitable
+# it can be reset with: set :aims_script, 'foo'
+set(:qsub) { 
+  "parallel.q -n #{nodes} -d #{memory} -t #{time} -ns -k #{aims_script}; sed '/\\btime\\b/ i\\ trap : SIGUSR1 SIGUSR2' #{aims_script}.cmd > #{aims_script}.cmd.new; mv #{aims_script}.cmd.new #{aims_script}.cmd; qsub -notify #{aims_script}.cmd"
+}
+
+# The remote host for data transfer of large files 
+role :data_transfer, "Your Data Transfer Server Here"
+# The remote host for job submission
+role :queue_submission, "Your Compute Cluster Server Here"

data/skeleton/config/aims.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+# Setup environment
+export OMP_NUM_THREADS=1
+export MKL_NUM_THREADS=1
+export MKL_DYNAMIC=FALSE
+
+export LD_LIBRARY_PATH=/u/local/compilers/intel/11.1/073/mkl/lib/em64t:/u/local/compilers/intel/11.1/073//lib/intel64:/u/local/compilers/intel/11.1/073/ipp/em64t/sharedlib:/u/local/compilers/intel/11.1/073/mkl/lib/em64t:/u/local/compilers/intel/11.1/073/tbb/intel64/cc4.1.0_libc2.4_kernel2.6.16.21/lib:/u/local/apps/scalapack/current/ib:/u/local/compilers/intel/11.0/current/mkl/lib/em64t/:/u/local/intel/11.1/openmpi/1.4.5/lib:/u/local/compilers/intel/11.1/080/mkl/lib/em64t:/u/local/compilers/intel/11.1/080/lib/intel64
+
+STATUSFILE=calc_status.yaml
+LOCKFILE=${STATUSFILE}.lock
+MACHINEFILE=hfile
+
+# Required by openmpi
+source /u/local/Modules/default/init/modules.sh
+module load intel/11.1
+module load openmpi/1.4
+
+
+# Set the jobid in the status file
+function setJobID() {
+	if [ ! -f $LOCKFILE ]; then
+		touch $LOCKFILE;
+		echo "jobid: ${JOB_ID}" >> $STATUSFILE
+		rm $LOCKFILE;
+	fi
+}
+
+# Define a function for modifying the status of the calculation        
+function setStatus() {
+        if [ ! -f $LOCKFILE ]; then
+                touch $LOCKFILE;
+        status=$1;
+        date_str=`date +'%Y-%m-%d %T %:z'`
+        TMPFILE=calc_status.tmp;
+        sed "s/status: .*/status: ${status}/; s/updated_at: .*/updated_at: ${date_str}/" $STATUSFILE > $TMPFILE;
+        mv $TMPFILE $STATUSFILE;
+                rm $LOCKFILE;
+        fi
+}
+
+
+
+# setup traps for early program termination
+# qsub with the -notify flag will send SIGUSR1(30) or SIGUSR2(31) before killing a job
+trap 'setStatus "ABORTED"; exit;' SIGUSR1 SIGUSR2
+
+# Set the status to running
+setJobID
+setStatus "RUNNING"
+
+# Run aims
+# $NSLOTS is set by the sun-grid-engine when qsub is invoked. 
+awk '{print $1 " slots=" $2}' $PE_HOSTFILE > $MACHINEFILE
+mpiexec -n $NSLOTS -machinefile $MACHINEFILE $HOME/bin/aims.071711_6.scalapack.mpi.x
+
+# Set the status to complete
+setStatus "COMPLETE"