aims 0.2.1 → 0.3.0

data/README.rdoc

@@ -73,7 +73,7 @@ And here is how you get a (100) surface with 7 layers and 20 angstrom of vacuum
 And here is how you can constrain the bottom three layers
   constrain = 3
   puts zb.get_001_surface(layers, vacuum, constrain)
-
+  
 == Scripts that come with the Aims GEM
 
 There are currently two scripts that come with the GEM

data/bin/aims_output.rb

@@ -28,6 +28,10 @@ optParser = OptionParser.new do |opts|
     options[:debug] = true
   end
 
+  opts.on('-g', '--geometry', 'Output Geometry for selected relaxation steps') do 
+    options[:geometry] = true
+  end
+
   opts.on('--geometry-delta', 'Display change from input geometry to final geometry') do
     options[:geometry_delta] = true
   end
@@ -59,7 +63,7 @@ begin
   }
 
   int_format = "%-20s %20i"
-  float_format = "%-20s %20.5f"
+  float_format = "%-20s 20.5f"
   exp_format = "%-20s %20.5e"
   
   sciter_format  = "%-20s %20i"
@@ -144,6 +148,10 @@ begin
         }
       end
 
+      if options[:geometry]
+        puts step.geometry.format_geometry_in
+      end
+
       puts "\n\n"
       
       
@@ -161,6 +169,8 @@ begin
     output.computational_steps.each{|cs| 
       puts int_format % [cs[:description], cs[:value]]
     }
+    
+    
     if options[:timings]
       output.timings.each{|t| puts "   " +timings_format % [t[:description], t[:cpu_time]]} 
     end

data/lib/aims.rb

@@ -29,6 +29,7 @@ require 'aims/geometry.rb'
 require 'aims/volume.rb'
 require 'aims/wurtzite.rb'
 require 'aims/zinc_blende.rb'
+require 'aims/kd_tree.rb'
 
 # {include:file:README.rdoc}
 module Aims

data/lib/aims/Tetragonal.rb

@@ -14,7 +14,9 @@ module Aims
     end
   end
   
+  # 
   class Gallium < Geometry    
+    
     def initialize(a, b, c, u, v)
       v1 = Vector[a/2.0, -b/2.0, 0]
       v2 = Vector[a/2.0, b/2.0, 0]

data/lib/aims/geometry.rb

@@ -23,8 +23,6 @@ module Aims
     # A three element array of lattice vectors for periodic systems
     attr_accessor :lattice_vectors
     
-    # An array of Aims::Bond objects calculated when the Geometry is defined.
-	  attr_accessor :bonds
 	
     # clip_planes is an array of planes
     # The planes are defined with respect to the vectors millerX and millerZ
@@ -107,30 +105,91 @@ module Aims
       end
     end
     
+      # Return the 
+    def bonds(visibility = :visibleOnly)
+      if (visibility == :visibleOnly) and (0 < @clip_planes.size)
+        @visibleBonds
+      else
+        @bonds
+      end
+    end
+    
+    # Remove the atoms satisfying the criteria specified in block
+    def remove_atoms
+      @atoms.reject!{|a|
+        yield a
+      }
+      recache_visible_atoms
+      self
+    end
+    
   # Generate and cache bonds for this geometry.
   # A bond will be generated for every pair of atoms closer than +bond_length+
-	def make_bonds(bond_length = 4.0)
+	def make_bonds(bond_length = 3.0)
 		# initialize an empty array
-		self.bonds = Array.new
+		@bonds = Array.new
 		
 		# Make bonds between all atoms
-		stack = atoms.dup
+    # stack = atoms.dup
+    atoms_extended = atoms.dup
+    if periodic?
+        v1 = lattice_vectors[0]
+        v2 = lattice_vectors[1]
+        atoms.each{|a|
+        [-1, 0, 1].each{|n1|
+              [-1, 0, 1].each{|n2|               
+                  atoms_extended << a.displace(n1*v1[0] + n2*v2[0], n1*v1[1] + n2*v2[1], n1*v1[2] + n2*v2[2])
+              }
+          }
+        }
+      end
+      
+		tree = KDTree.new(atoms_extended, 3)
+    atoms.each{|a|
+      r = 4
+      neighbors = tree.find([a.x-r, a.x+r], [a.y-r, a.y+r], [a.z-r, a.z+r])
+      neighbors.each{|n|
+        b = Bond.new(a, n)
+        @bonds << b if b.length < bond_length
+      }
+    }
 		
-		atom1 = stack.pop
-		while (not stack.empty?)
-			stack.each{|atom2|
-				b = Bond.new(atom1, atom2)
-				self.bonds << b if b.length < bond_length
-			}
-			atom1 = stack.pop
-		end
+    # atom1 = stack.pop
+    # while (not stack.empty?)
+    #   stack.each{|atom2|
+    #     b = Bond.new(atom1, atom2)
+    #     @bonds << b if b.length < bond_length
+    #     if periodic?
+    #           v1 = lattice_vectors[0]
+    #           v2 = lattice_vectors[1]
+    #       [-1, 0, 1].each{|n1|
+    #         [-1, 0, 1].each{|n2|               
+    #               b = Bond.new(atom1, atom2.displace(n1*v1[0] + n2*v2[0], n1*v1[1] + n2*v2[1], n1*v1[2] + n2*v2[2]))
+    #               @bonds << b if b.length < bond_length
+    #         }
+    #       }
+    #     end
+    #   }
+    #   atom1 = stack.pop
+    # end
 	end
 
+  # Return true if this geometry has lattice vectors defined
+  # and is periodic in R3
+  def periodic?
+    if lattice_vectors and lattice_vectors.size == 3
+        return true
+    else  
+        return false
+    end
+  end
+  
   # Add a clip Plane to the unit cell
   # recache the visible atoms if called with +recache = true+ (the Default)
   def add_plane(aPlane, recache = true)
     self.clip_planes << aPlane
     recache_visible_atoms if recache
+    aPlane
   end
 	
     # Add a clipping plane defined by the outward normal (h,k,l)
@@ -255,7 +314,26 @@ module Aims
         @visibleAtoms << a if i == 0
       }
       
-      make_bonds if makeBonds
+      if @visibleBonds
+        @visibleBonds.clear
+      else
+        @visibleBonds = []
+      end
+      
+      make_bonds if (makeBonds or @bonds.nil?)
+
+      @bonds.each{|b|
+        a0 = b[0]
+        a1 = b[1]
+        i0 = plane_count
+        i1 = plane_count
+        @clip_planes.each{|p|
+          i0 = i0-1 if 0 >= p.distance_to_point(a0.x, a0.y, a0.z)
+          i1 = i1-1 if 0 >= p.distance_to_point(a1.x, a1.y, a1.z)
+        }
+        @visibleBonds << b if (i0 + i1) < 2
+      }
+      
     end
     
     # Rotate the geometry in 3 dimensions. The rotation is 
@@ -283,9 +361,10 @@ module Aims
         mat*v
       }
       uc = Geometry.new(newatoms, newvectors)
-      uc.cart_to_miller = mat*self.cart_to_miller
-      uc.miller_to_cart = uc.cart_to_miller.inverse
-
+      if self.cart_to_miller
+        uc.cart_to_miller = mat*self.cart_to_miller
+        uc.miller_to_cart = uc.cart_to_miller.inverse
+      end
       return uc
     end
     
@@ -364,7 +443,7 @@ module Aims
     
     # Remove the specified atom from the unit cell
     def remove_atom(atom)
-      atoms.reject!{|a|
+      atoms(:all).reject!{|a|
        a.id == atom.id 
       }
       # Force a rehash of nearest-neighbor tree
@@ -416,7 +495,7 @@ module Aims
       u.lattice_vectors = [Vector[nx.abs*v1[0], nx.abs*v1[1], nx.abs*v1[2]], 
                            Vector[ny.abs*v2[0], ny.abs*v2[1], ny.abs*v2[2]], 
                            Vector[nz.abs*v3[0], nz.abs*v3[1], nz.abs*v3[2]]]
-      u.make_bonds 
+      # u.make_bonds 
       return u     
     end
 
@@ -424,7 +503,7 @@ module Aims
     # Currently does no validation on lattice vectors on miller vectors
     def <<(aGeometry)
       self.atoms.concat(aGeometry.atoms)
-	  self.make_bonds
+    # self.make_bonds
 	  return self
     end
     
@@ -446,9 +525,9 @@ module Aims
     end
 
     # return a string in xyz format
-    def format_xyz
+    def format_xyz(title = "Aims Geoemtry")
       output = self.atoms.size.to_s + "\n"
-      output << "Aims Geometry \n"
+      output << "#{title} \n"
       self.atoms.each{ |a| 
         output << [a.species, a.x.to_s, a.y.to_s, a.z.to_s].join("\t") + "\n"
       }
@@ -478,7 +557,7 @@ module Aims
 
   # Move all atoms inside the primitive volume defined by the
   # six planes of the lattice vectors
-    def correct
+    def correct(repeat_border_atoms = false)
       
       # Hash for storing bounding planes and the out-of-plane vector
       # by which each atom will be displaced to move it into the primitive volume
@@ -519,25 +598,58 @@ module Aims
       # Make a coyp of the unit cell
       new_unit_cell = self.copy
 
+      # atoms on the border will be repeated with
+      # periodicity of lattice vectors for better rendering
+      border_atoms = {}
+      
       # Move each atom behind all the planes
-      new_unit_cell.atoms(false).each do |atom|
+      new_unit_cell.atoms(false).each_with_index do |atom, i|
         planes_vecs.each_pair do |p, v|
           if p.distance_to_point(0,0,0) == 0
             # If the plane intersects the origin then 
             # move atoms not on the plane (inequality)
-            while p.distance_to_point(atom.x, atom.y, atom.z) > 0
+            while p.distance_to_point(atom.x, atom.y, atom.z) > 1e-4
               atom.displace!(v[0], v[1], v[2])
             end
           else
             # Move atoms that lie on the plane if the plane doesn't intersect the origin
-            while p.distance_to_point(atom.x, atom.y, atom.z) >= 0
+            while p.distance_to_point(atom.x, atom.y, atom.z) >= -1e-4
               atom.displace!(v[0], v[1], v[2])
             end
           end
+          
+          # This part repeats atoms on the unit cell boundaries
+          # useful for drawing pictures, but these atoms are really repeats
+          # Add each border that intersects the atom to a list
+          if p.distance_to_point(atom.x, atom.y, atom.z) == 0
+            if border_atoms[atom]
+              border_atoms[atom] << v
+            else
+              border_atoms[atom] = [v]
+            end
+          end
         end
       end
+
+      
+
+      # Add more border atoms for each combination of lattice planes
+      if repeat_border_atoms
+        border_atoms.each_pair{|atom, planes|
+          planes.size.times{|i|
+            combos = Volume.choose(planes, i+1)
+            combos.each{|combo|
+              x = combo.inject(0){|sum, v| sum = sum + v[0]}
+              y = combo.inject(0){|sum, v| sum = sum + v[1]}
+              z = combo.inject(0){|sum, v| sum = sum + v[2]}
+              puts [x,y,z]
+              new_unit_cell.atoms(:allAtoms) << atom.displace(x, y, z)
+            }
+          }
+        }
+      end
       new_unit_cell.atoms.uniq!
-      new_unit_cell.make_bonds
+      # new_unit_cell.make_bonds
       return new_unit_cell
 
     end

data/lib/aims/geometry_parser.rb

@@ -3,17 +3,7 @@ module Aims
   
   # Utility class for parsing an Aims geometry file
   # Example Usage:
-  #  geom = Aims::GeometryParser.parse("geometry.in")
-  #  
-  #  # Constrain atoms below some z value
-  #  geom.each{|atom| 
-  #    if (atom.z < someValue)
-  #        atom.constrain = true
-  #    end
-  #  }
-  #  File.open("new_geometry.in", "w") do |f|
-  #     f.puts geom.format_geometry_in
-  #  end
+  #  uc = Aims::GeometryParser.parse("geometry.in")
   class GeometryParser
     
     # Parse a String representation of a geometry.in file
@@ -46,7 +36,7 @@ module Aims
           atoms.last.constrain << c
         end
       }
-      Geometry.new(atoms, vectors)
+      Geometry.new(atoms, vectors, false)
     end
 
     # Parse a geometry.in file

data/lib/aims/kd_tree.rb

@@ -0,0 +1,94 @@
+module Aims
+  # Courtesy of https://gist.github.com/cbrumelle/328423
+class KDTree
+   attr_reader :root
+   attr_reader :points
+ 
+   def initialize(points, dim)
+     @dim = dim
+     @root = KDNode.new(dim).parse(points)
+   end
+ 
+   def add_node(point)
+     @root.add(point)
+   end
+ 
+   def find(*range)
+     range.collect!{ |pa|
+       pa = Range.new(pa.first, pa.last) if pa.kind_of? Array
+     }
+     @points = []
+     query(range, @root)
+     @points
+   end
+ 
+   def query(range, node)
+     axis = node.axis
+     median = node.location[axis]
+ 
+     if node.left && (median >= range[axis].begin)
+       query(range, node.left);  # /* Skip left if max of left tree (median) is out of range */
+     end
+     if node.right && (median <= range[axis].end)
+       query(range, node.right); # /* Skip right if min of right tree (median) is out of range */
+     end
+     if (0..@dim-1).all?{|ax|
+         range[ax].include? node.location[ax]
+       }
+       @points << node.location;
+     end
+   end
+ 
+   def print
+     @root.print
+   end
+end
+ 
+class KDNode
+   attr_reader :left, :right
+   attr_reader :location
+ 
+   attr_reader :axis
+ 
+   def initialize(dim, location=nil, left=nil, right=nil)
+     @dim = dim
+     @location = location
+     @left = left
+     @right = right
+   end
+ 
+   def parse(points, depth = 0)
+     @axis = depth % @dim
+ 
+     points = points.sort_by{|point| point[@axis]}
+     half = points.length / 2
+ 
+     @location = points[half]
+     @left = KDNode.new(@dim).parse(points[0..half-1], depth+1) unless half < 1
+     @right = KDNode.new(@dim).parse(points[half+1..-1], depth+1) unless half+1 >= points.length
+     self
+   end
+ 
+   def add(point)
+     if @location[@axis] < point[@axis]
+       @left ? @left.add(point) : @left = KDNode.new(point)
+     else
+       @right ? @right.add(point) : @right = KDNode.new(point)
+     end
+   end
+ 
+   def remove
+     self.parse(@left.to_a + @right.to_a, @axis)
+   end
+ 
+   def to_a
+     @left.to_a + [@location] + @right.to_a
+   end
+ 
+   def print(l=0)
+     @left.print(l+1) if @left
+     puts("  "*l + @location.inspect)
+     @right.print(l+1) if @right
+   end
+end
+end

data/lib/aims/output.rb

@@ -208,6 +208,7 @@ module Aims
   class AimsOutput
     # Each Aims::GeometryStep geometry relaxation step
     attr_accessor :geometry_steps
+    alias_method :relaxation_steps, :geometry_steps
     
     # The k-point grid for periodic calculations
     attr_accessor :k_grid
@@ -246,7 +247,7 @@ module Aims
     end
     
     def final_geometry
-      self.geometry_steps.last.geometry
+        self.geometry_steps.last.geometry
     end
     
     def final_step
@@ -397,6 +398,7 @@ module Aims
       retval.original_file = filename
       
       File.open(filename, 'r') do |f|
+        counter = 0
         f.each_line{|line|
           case line
             when /Found k-point grid:/
@@ -459,8 +461,9 @@ module Aims
               retval.geometry_steps << GeometryStep.new 
               retval.geometry_step.step_num = last_step_num + 1
               retval.geometry_step.geometry = OutputParser.parse_updated_geometry(f, n_atoms)
-            #  retval.geometry_step.geometry.lattice_vectors = vectors
-              
+              unless retval.geometry_step.geometry.lattice_vectors
+                retval.geometry_step.geometry.lattice_vectors = vectors
+              end
             when /\ Final\ atomic\ structure\:/
               retval.geometry_step.geometry = OutputParser.parse_updated_geometry(f, n_atoms)
              # retval.geometry_step.geometry.lattice_vectors = vectors
@@ -476,7 +479,6 @@ module Aims
           end
         }
       end
-
       return retval
       
     end

data/lib/aims/plane.rb

@@ -9,6 +9,8 @@ module Aims
   class Plane
     attr_reader :a, :b, :c, :d
   
+    include Vectorize
+    
     # 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)
@@ -53,10 +55,35 @@ module Aims
       v*(1/v.r)
     end
     
-    # The equation for the interstion of a ray and a plane
-    # NOT YET IMPLEMENTED
+    # The equation for the interstion of ray defined by r(t) = (a + b*t)
+    # [a, b] are vectors where a is the tail of the ray and b points in the direction of the ray and t > 0
+    # and the plane normal Pn = [A B C]
+    #
+    # Substituting r(t) into the equation of the plane gives:
+    #  A(ax + bx*t) + B(ay + by*t) + C(az + bz*t) + D = 0 
+    #  
+    # Solve for t
+    # t = (Pn dot a + D)/(Pn dot b) = V0 / Vd
+    # if: 
+    #    Vd = 0, then no intersection
+    #    t < 0, then intersection behind ray origin
+    #
+    # Find point of intersection
+    # [(ax + bx*t) (ay + by*t) (az + bz*t)]
     def intersection_with_ray(a, b)
-      raise "Sorry. Plane#intersection_with_ray is not yet implemented"
+      n = self.unit_normal
+      vd = dot(n, b)
+      if vd == 0
+        return nil
+      else
+        v0 = dot(n, a) + @d
+        t = -v0/vd
+        if t < 0
+          return nil
+        else
+          return a + b*t
+        end
+      end
     end
     
     # Displace this plane a distance in the direction of its normal

data/lib/aims/wurtzite.rb

@@ -20,10 +20,8 @@ module Aims
     
     def get_bulk
       # The lattice constant
-      a = (ARGV[0] || 4.0).to_f
+      a = lattice_const
       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')

data/lib/aims/zinc_blende.rb

@@ -46,45 +46,43 @@ module Aims
     end
 
     # Fill the given volume with atoms
-    #   This method is still under development. It is removed for the 0.2.0 release 
-    #  
-    # 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
+    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,

data/spec/plane_spec.rb

@@ -0,0 +1,35 @@
+require 'aims'
+include Aims
+
+describe Plane do
+  p = Plane.new(0,0,1,0)
+  
+  it "should intersect the ray +z at (0 0 0)" do
+    a = Vector[0,0,0]
+    b = Vector[0,0,1]
+    x = p.intersection_with_ray(a, b)
+    x.should eq(a)
+  end
+  
+  it "should intersect the ray +z with origin (0,0,-1) at (0 0 0)" do
+    a = Vector[0,0,-1]
+    b = Vector[0,0,1]
+    x = p.intersection_with_ray(a, b)
+    x.should eq(Vector[0,0,0])
+  end
+  
+  it "should not intersect the ray +x" do
+    a = Vector[0,0,0]
+    b = Vector[1,0,0]
+    x = p.intersection_with_ray(a,b)
+    x.should be_nil
+  end
+  
+  it "should not intersect the +z ray with origin (0,0,1)" do
+    a = Vector[0,0,1]
+    b = Vector[0,0,1]
+    x = p.intersection_with_ray(a,b)  
+    x.should be_nil  
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aims
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-01 00:00:00.000000000Z
+date: 2013-05-22 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &3864410 !ruby/object:Gem::Requirement
+  requirement: &5425000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3864410
+  version_requirements: *5425000
 description: Support for generation and parsing of input and output files for FHI-AIMS
   DFT package
 email: joshua.shapiro@gmail.com
@@ -38,6 +38,7 @@ files:
 - lib/aims/cube.rb
 - lib/aims/geometry.rb
 - lib/aims/geometry_parser.rb
+- lib/aims/kd_tree.rb
 - lib/aims/output.rb
 - lib/aims/plane.rb
 - lib/aims/Tetragonal.rb
@@ -50,6 +51,7 @@ files:
 - spec/atom_spec.rb
 - spec/bond_spec.rb
 - spec/output_spec.rb
+- spec/plane_spec.rb
 - spec/zinc_blende_spec.rb
 homepage: https://github.com/jns/Aims
 licenses: []
@@ -80,5 +82,6 @@ test_files:
 - spec/atom_spec.rb
 - spec/bond_spec.rb
 - spec/output_spec.rb
+- spec/plane_spec.rb
 - spec/zinc_blende_spec.rb
 has_rdoc: