aims 0.2.0

data/lib/aims/plane.rb

@@ -0,0 +1,74 @@
+module Aims
+  
+  # A Class representing a plane.
+  # Internally stored in Hessian Normal Form.
+  # 0 = Ax + By + Cz - D
+  #
+  # (A,B,C) is the plane normal.
+  # D is the distance from the origin.
+  class Plane
+    attr_reader :a, :b, :c, :d
+  
+    # Initialize this plane with the normal (a,b,c) and a
+    # point (x,y,z) on the plane
+    def initialize(a, b, c, x=0, y=0, z=0)
+      @a = a
+      @b = b
+      @c = c
+      if (@a == 0 and @b == 0 and @c == 0)
+        raise "Invalid definition of plane."
+      end
+      @d = a*x + b*y + c*z
+    end
+
+    # return some arbitrary point on the plane
+    def any_point_on_plane
+      
+      unless (@c == 0)
+        return Vector[0, 0, @d/@c]
+      end
+      
+      unless (@b == 0)
+        return Vector[0, @d/@b, 0]
+      end
+      
+      unless (@a == 0)
+        return Vector[@d/@a, 0, 0]
+      end
+      
+      # Actually if we get to this point, the plane undetermined and all of R3 satisfies the definition
+      return Vector[0,0,0]
+    end
+    
+    # Return the distance to point (x,y,z)
+    #
+    # distance = D - Ax - By - Cz
+    def distance_to_point(x, y, z)
+      a*x + b*y + c*z - d
+    end
+    
+    # Return the unit normal Vector[a, b, c]
+    def unit_normal
+      v = Vector[@a, @b, @c]
+      v*(1/v.r)
+    end
+    
+    # The equation for the interstion of a ray and a plane
+    # NOT YET IMPLEMENTED
+    def intersection_with_ray(a, b)
+      raise "Sorry. Plane#intersection_with_ray is not yet implemented"
+    end
+    
+    # Displace this plane a distance in the direction of its normal
+    def displace_along_normal(distance)
+      @d += distance
+    end
+    
+    # Two planes are equal if there ABCD parameters are equal
+    def ==(aPlane)
+      @a == aPlane.a and @b == aPlane.b and @c == aPlane.c and @d == aPlane.d
+    end
+    alias_method :eql?, :==
+    
+  end
+end

data/lib/aims/vectorize.rb

@@ -0,0 +1,22 @@
+module Aims
+  module Vectorize
+  
+      # Dot product of two n-element arrays
+      def dot(a, b)
+        unless a.size == b.size
+          raise "Vectors must be the same length"
+        end
+  
+        # Make element-by-element array of pairs
+        (a.to_a).zip(b.to_a).inject(0) {|tot, pair| tot = tot + pair[0]*pair[1]}
+      end
+
+      # Cross product of two arrays of length 3
+      def cross(b,c)
+        unless b.size == 3 and c.size == 3
+          raise "Vectors must be of length 3"
+        end
+        Vector[b[1]*c[2] - b[2]*c[1], b[2]*c[0] - b[0]*c[2], b[0]*c[1] - b[1]*c[0]]
+      end
+    end
+end

data/lib/aims/volume.rb

@@ -0,0 +1,137 @@
+module Aims
+  
+# A volume is defined by a minimum of four planes that intersect in a minimum 
+# of four points. The normals of the planes must all point outward. This is tested
+# 
+  class Volume
+  
+    include Vectorize
+    
+    # Quick recursive method for calculating combinations
+    def Volume.choose(list, num, head = [])
+
+      _head = head.dup
+      _list = list.dup
+      _num = num
+
+      if _num == 0 
+        return [_head]
+      end
+        
+      new_heads = []
+      while _list.size > _num-1
+          h = _head + [_list.shift]
+          new_heads += Volume.choose(_list, num-1, h)
+        end
+      return new_heads
+      
+    end
+    
+    
+    # Return an array of tuples that define the 
+    # vertices of intersection of these planes
+    # Vertices are removed that lie in front of any plane
+    def Volume.intersection_points(planes)
+      combos = Volume.choose(planes, 3)
+      points = []
+      combos.each{|c|
+        n1 = c[0].unit_normal
+        n2 = c[1].unit_normal
+        n3 = c[2].unit_normal
+        d = Matrix[n1, n2,n3].transpose.det
+        
+        # The determinant is zero if any two planes are parallel
+        unless (d == 0)
+          p1 = c[0].any_point_on_plane
+          p2 = c[1].any_point_on_plane
+          p3 = c[2].any_point_on_plane
+        
+          # This defines the point of intersection of three planes.
+          points << (cross(n2,n3)*dot(p1, n1) + cross(n3,n1)*dot(p2,n2) + cross(n1,n2)*dot(p3, n3))*(1/d)
+        end
+      }
+      
+      # Only keep the points that are behind all planes
+      keepers = []
+      points.each{|pt|
+        keep = true
+        planes.each {|pl|
+          keep = (pl.distance_to_point(pt[0], pt[1], pt[2]) <= 0)
+          break unless keep
+        }
+        keepers << pt if keep
+      }
+      return keepers
+    end
+    
+    def initialize(planes)
+      
+      points = Volume.intersection_points(planes)
+      if (4 > points.size)
+        raise "Planes do not intersect in a closed volume."
+      end
+      @points = points
+      @planes = planes
+    end
+    
+    # Return the bounding box for this volume
+    def bounding_box
+      unless @bbox
+        p = @points[0]
+        minX = p[0]
+        maxX = p[0]
+        minY = p[1]
+        maxY = p[1]
+        minZ = p[2]
+        maxZ = p[2]
+        @points.each{|p|
+          minX = p[0] if p[0] < minX  
+          maxX = p[0] if p[0] > maxX  
+          minY = p[1] if p[1] < minY  
+          maxY = p[1] if p[1] > maxY  
+          minZ = p[2] if p[2] < minZ  
+          maxZ = p[2] if p[2] > maxZ  
+        }
+        @max = Vector[maxX, maxY,maxZ]
+        @min = Vector[minX, minY, minZ]
+        @bbox = Volume.new([Plane.new(-1,0,0, minX, minY, minZ), 
+                           Plane.new(0,-1,0, minX, minY, minZ),
+                           Plane.new(0,0,-1, minX, minY, minZ),
+                           Plane.new(1,0,0, maxX, maxY, maxZ),
+                           Plane.new(0,1,0, maxX, maxY, maxZ), 
+                           Plane.new(0,0,1, maxX, maxY, maxZ)])
+      end
+      @bbox
+    end
+    
+    # Return the point on the bounding box that represents the maximum value
+    # of any cartesian coordinate (the upper right corner)
+    def max_point
+      # generate the bounding box if not already done
+      bounding_box
+      # return the max
+      @max
+    end
+    
+    # Return the point on the bounding box that represents the minimum value
+    # of any cartesian coordinate (the lower left corner).
+    def min_point
+      # generate the bounding box if not already done
+      bounding_box
+      # return the min
+      @min
+    end
+    
+    # A volume contains a point if it lies behind all the planes
+    def contains_point(x,y,z)
+      behind = true
+      @planes.each{|p|
+        behind = (0 >= p.distance_to_point(x,y,z))
+        break if not behind
+      }
+      return behind
+    end
+    
+  end
+
+end

data/lib/aims/wurtzite.rb

@@ -0,0 +1,48 @@
+
+require 'mathn'
+
+module Aims
+  class Wurtzite
+    
+    include Math
+    
+    attr_accessor :lattice_const, :cation, :anion
+
+    # Initialize the wurtzite Geometry
+    # cation and anion are the  atomic 
+    # species occupying the two different sub-lattices.
+    # lattice_const specifies the lattice constant
+    def initialize(cation, anion, lattice_const)
+      self.lattice_const = lattice_const
+      self.cation = cation
+      self.anion = anion
+    end
+    
+    def get_bulk
+      # The lattice constant
+      a = (ARGV[0] || 4.0).to_f
+      c = 1.63299*a # sqrt(8/3)a
+      #a = 6.19231 # Strained GaSb, Unstrained GaSb is 6.22
+      #a = 5.75 # Unstrained GaAs
+
+      # The atoms on a HCP
+      as1 = Atom.new(0,0,0,'As')
+      as2 = as1.displace(0.5*a, 0.33333*a, 0.5*c)
+
+      ga1 = Atom.new(0.0, 0.0, c*0.386, 'Ga')
+      ga2 = ga1.displace(0.5*a,0.33333*a, 0.5*c)
+
+      # The lattice Vectors
+      v1 = Vector[1.0, 0.0, 0.0]*a
+      v2 = Vector[0.5, 0.5*sqrt(3), 0.0]*a
+      v3 = Vector[0.0, 0.0, 1.0]*c
+
+      # The unit cell
+      wz = Geometry.new([as1,ga1,as2,ga2], [v1, v2, v3])
+      
+      # wz.set_miller_indices(millerX, millerY, millerZ)
+      return wz
+    end
+  end
+end
+   

data/lib/aims/zinc_blende.rb

@@ -0,0 +1,311 @@
+require 'mathn'
+
+module Aims
+
+# Factory class for generating slabs for various crystal surfaces
+# of specified thickness and with the specified vacuum. 
+# Example:
+#   zb = ZincBlende.new("Ga", "As", 5.65)
+#   zb.get_bulk -> # returns the a unit cell with two atoms
+#   zb.get_111B_surface(7, 20, 3) # returns a slab of 111B 7 monolayers thick, with 20 angstrom of vacuum, and the bottom 3 layers constrained
+  class ZincBlende
+
+    include Vectorize
+    include Math
+    
+    attr_accessor :lattice_const, :cation, :anion
+
+    # Initialize the zinc-blende Geometry
+    # cation and anion are the  atomic 
+    # species occupying the two different sub-lattices.
+    # lattice_const specifies the lattice constant
+    def initialize(cation, anion, lattice_const)
+      self.lattice_const = lattice_const
+      self.cation = cation
+      self.anion = anion
+    end
+    
+    # Return the traditional unit cell of bulk zinc blende
+    def get_bulk
+      b = 0.25*self.lattice_const
+      a1 = Atom.new(0, 0, 0, self.cation)
+      a2 = Atom.new(b, b, b, self.anion)
+      
+      v1 = Vector[0.5, 0.5, 0.0]*self.lattice_const
+      v2 = Vector[0.5, 0.0, 0.5]*self.lattice_const
+      v3 = Vector[0.0, 0.5, 0.5]*self.lattice_const
+      zb = Geometry.new([a1, a2], [v1, v2, v3])
+      
+      millerx = [1, 0, 0]
+      millery = [0, 1, 0]
+      millerz = [0, 0, 1]
+      
+      zb.set_miller_indices(millerx, millery, millerz)
+      
+      return zb
+    end
+
+    # Fill the given volume with atoms
+    def fill_volume(volume)
+      
+      # First fill a cube that bounds the volume
+      max = volume.max_point
+      min = volume.min_point
+      
+      dx = max[0] - min[0]
+      dy = max[1] - min[1]
+      dz = max[2] - min[2]
+      
+      bulk = get_bulk
+      
+      # This inverse matrix gives the number of repetitions 
+      m = Matrix[[dx,0,0], [0,dy,0], [0,0,dz]]
+      v = Matrix[bulk.lattice_vectors[0].to_a, 
+                 bulk.lattice_vectors[1].to_a,
+                 bulk.lattice_vectors[2].to_a]
+      rep_mat = m*(v.inverse)
+      
+      # The only way I can figure out how to do this for an 
+      # arbitrary set of lattice vectors is to fill the volume
+      # out along each edge of the super-cube and then eliminate duplicates
+      atoms = []
+      3.times do |i|
+        # this vector is the number of repetitions in the unit cell
+        # to fill the volume out along the i-th edge of the super-cube
+        n_repeat = rep_mat.row(i)
+        
+        # Give the proper sign to the repeat
+        nx = (n_repeat[0] < 0) ? n_repeat[0].floor-1 : n_repeat[0].ceil+1
+        ny = (n_repeat[1] < 0) ? n_repeat[1].floor-1 : n_repeat[1].ceil+1
+        nz = (n_repeat[2] < 0) ? n_repeat[2].floor-1 : n_repeat[2].ceil+1
+        
+        atoms += bulk.repeat(nx, ny, nz).atoms.find_all{|a| volume.contains_point(a.x, a.y, a.z)}
+      end
+      Geometry.new(atoms.uniq)
+    end
+
+    # Return a unit cell for a slab of 001 
+    # Specify the number of atomic monolayers,
+    # the vacuum thickness in angstrom,
+    # and the number of layers to constrain at the base of the slab
+    def get_001_surface(monolayers, vacuum, constrain_layers = 0)
+      anion = Atom.new(0,0,0,self.cation)
+      cation = Atom.new(0.25*self.lattice_const, 0.25*self.lattice_const, 0.25*self.lattice_const, self.anion)
+      v1 = Vector[0.5, 0.5, 0]*self.lattice_const
+      v2 = Vector[-0.5,0.5,0]*self.lattice_const
+      v3 = Vector[0.5, 0, 0.5]*self.lattice_const
+      
+      zb = Geometry.new([anion, cation], [v1,v2,v3])
+      millerX = [1,0,0]
+      millerY = [0,1,0]
+      millerZ = [0,0,1]
+      zb.set_miller_indices(millerX, millerY, millerZ)
+      
+      # Repeat the unit cell.  The unit cell is a bi-layer so divide by 2
+      zb = zb.repeat(1,1,(monolayers/2).ceil)
+
+      if 0 < vacuum
+        # Add vacuum
+        monolayerSep = v3[2]/2
+        zb.lattice_vectors[2] = Vector[0, 0, monolayers*monolayerSep.abs + vacuum.to_f]
+        # Move everything into a nice tidy unit cell. 
+        zb = zb.correct
+      end
+
+      minZ = zb.atoms.min{|a,b| a.z <=> b.z}.z
+      
+      # Reject the top layer of atoms if an odd number of monolayers was requested.
+      # This is necessary because the primitive cell is a bilayer
+      zb.atoms.reject! {|a| 
+        a.z >= (minZ + monolayerSep.abs*monolayers)
+      }
+      
+      # Constrain the bottom layers
+      zb.atoms.each{|a|
+        if (a.z < minZ + monolayerSep.abs*constrain_layers)
+          a.constrain = ".true."
+        end
+      }
+      
+      # Return the completed unit cell
+      return zb
+    end
+    alias_method :get_100_surface, :get_001_surface
+    alias_method :get_010_surface, :get_001_surface
+
+    # Return a unit cell for a slab of 111A (anion terminated)
+    # specify the number of atomic monolayers,
+    # the vacuum thickness in angstrom,
+    # and the number of layers to constrain at the base of the slab
+    def get_111A_surface(monolayers, vacuum, constrain_layers = 0)
+      # get the 111B surface, then reflect it about z=0
+      get_111_surface("A", monolayers, vacuum, constrain_layers)
+    end
+
+    # Return a unit cell for a slab of 111A (cation terminated)
+    # specify the number of atomic monolayers,
+    # the vacuum thickness in angstrom,
+    # and the number of layers to constrain at the base of the slab
+    def get_111B_surface(monolayers, vacuum, constrain_layers = 0)
+      get_111_surface("B", monolayers, vacuum, constrain_layers)
+    end
+
+    # Return a unit cell for a slab of 111
+    # dir is either "A" or "B" for the cation or anion terminated slab
+    # specify the number of atomic monolayers 
+    # and the vacuum thickness in angstrom
+    def get_111_surface(dir, monolayers, vacuum, constrain_layers = 0)
+
+      if dir == "A"
+        top_atom = self.anion
+        bot_atom = self.cation
+      elsif dir == "B"
+        top_atom = self.cation
+        bot_atom = self.anion
+      else
+        raise "Direction must be either A or B"
+      end
+      
+      # The atoms on a FCC 
+      as1 = Atom.new(0.0, 0.0, 0.0, top_atom)
+      ga1 = Atom.new(0.0, 0.0, -sqrt(3)/4*self.lattice_const, bot_atom)
+
+      # The lattice Vectors
+      v1 = Vector[0.5*sqrt(2), 0.0, 0.0]*self.lattice_const
+      v2 = Vector[sqrt(2)*0.25, sqrt(6)*0.25, 0.0]*self.lattice_const
+      v3 = Vector[sqrt(2)*0.25, sqrt(2.0/3.0)*0.25, -1*sqrt(4.0/3.0)*0.5]*self.lattice_const
+
+      # The unit cell
+      zb = Geometry.new([as1, ga1], [v1, v2, v3])
+
+      # The Miller Indices
+      millerX = [-1, 1, 0]  # Orientation of the crystal pointing in the cartesian +x axis
+      millerY = [1, 1, -2]  # Orientation of the crystal pointing in the cartesian +y axis
+      millerZ = [-1, -1, -1] # Orientation of the crystal pointing in the cartesian +z axis
+
+      zb.set_miller_indices(millerX, millerY, millerZ)
+
+      # Repeat the unit cell and add vacuum
+      if 0 < vacuum 
+        # We actually repeat the unit cell monolayers+1 times because
+        # I will strip off the top and bottom atoms to make the proper surface
+        zb = zb.repeat(1,1,monolayers+1)
+        
+        bilayerSep = v3[2]
+        zb.lattice_vectors[2] = Vector[0, 0, monolayers*(bilayerSep.abs) + vacuum]
+
+        # Strip off the top and bottom atom
+        minZ = zb.atoms.min{|a,b| a.z <=> b.z}.z
+        maxZ = zb.atoms.max{|a,b| a.z <=> b.z}.z
+
+        zb.atoms.reject!{|a| a.z == maxZ}
+        zb.atoms.reject!{|a| a.z == minZ}
+
+        # Constrain the bottom layers if requested
+        if 0 < constrain_layers
+          # get the min again because we removed the atoms at minZ above
+          minZ = zb.atoms.min{|a,b| a.z <=> b.z}.z
+          constrain_below = minZ + bilayerSep.abs*constrain_layers
+          zb.atoms.each{|a|
+            if (a.z < constrain_below)
+              a.constrain = ".true."
+            end
+          }
+        end
+      end
+      
+      zb
+    end
+
+    # return a unit cell for a slab of 112 
+    # specify the number of atomic monolayers and the vacuum thickness in angstrom
+    def get_112_surface(monolayers, vacuum=0, constrain_layers = 0)
+      atom1 = Atom.new(0,0,0,self.cation)
+      atom2 = Atom.new(self.lattice_const*sqrt(3)/2, 0, 0, self.anion)
+      
+      v1 = Vector[sqrt(3), 0, 0]*self.lattice_const
+      v2 = Vector[0, sqrt(2)/2, 0]*self.lattice_const
+      v3 = Vector[1/sqrt(3), 1/(sqrt(3)*2), -1/(sqrt(3)*2)]*self.lattice_const
+      
+      millerX = Vector[1, 1, -2];
+      millerY = Vector[-1, 1, 0];
+      millerZ = Vector[-1, -1, -1]
+
+      # The unit cell
+       zb = Geometry.new([atom1, atom2], [v1, v2, v3])
+       zb.set_miller_indices(millerX, millerY, millerZ)
+
+       # Repeat the unit cell
+       zb = zb.repeat(1,1,monolayers)
+
+
+       if 0 < vacuum
+         # Add vacuum
+         monolayerSep = v3[2]
+         zb.lattice_vectors[2] = Vector[0, 0, (monolayers*monolayerSep).abs + vacuum.to_f]
+         # Move everything into a nice tidy unit cell. 
+         zb = zb.correct
+       end
+
+       # # Constrain the bottom 2 layers
+       # zb.atoms.each{|a|
+       #   if (a.z < monolayerSep*2)
+       #     a.constrain = ".true."
+       #   end
+       # }
+
+
+       # Return the completed unit cell
+       return zb
+    end
+    
+    
+    # Return a unit cell for a slab of 110
+    # specify the number of atomic monolayers 
+    # and the vacuum thickness in angstrom
+    def get_110_surface(monolayers, vacuum=0, constrain_layers = 0)
+
+      # The atoms on a FCC 
+      atom1 = Atom.new(0,0,0,self.cation)
+      atom2 = Atom.new(self.lattice_const*1/(2*sqrt(2)), self.lattice_const*0.25, 0.0, self.anion)
+
+      # The lattice Vectors
+      v1 = Vector[1/sqrt(2), 0.0, 0.0]*self.lattice_const
+      v2 = Vector[0.0, 1.0, 0.0]*self.lattice_const
+      v3 = Vector[1/(2*sqrt(2)), -0.5, 1/(2*sqrt(2))]*self.lattice_const
+
+      # The miller indices for each primitive cartesian direction
+      millerX = Vector[1, -1, 0]
+      millerY = Vector[0, 0, 1]
+      millerZ = Vector[1, 1, 0]
+
+      # The unit cell
+      zb = Geometry.new([atom1, atom2], [v1, v2, v3])
+      zb.set_miller_indices(millerX, millerY, millerZ)
+
+      # Repeat the unit cell
+      zb = zb.repeat(1,1,monolayers)
+
+
+      if 0 < vacuum
+        # Add vacuum
+        monolayerSep = v3[2]
+        zb.lattice_vectors[2] = Vector[0, 0, monolayers*monolayerSep.abs + vacuum.to_f]
+        # Move everything into a nice tidy unit cell. 
+        zb = zb.correct
+      end
+
+      # # Constrain the bottom layers
+      zb.atoms.each{|a|
+        if (a.z < monolayerSep*constrain_layers)
+          a.constrain = ".true."
+        end
+      }
+
+      
+      # Return the completed unit cell
+      return zb
+    end
+  end
+
+end