vasputils 0.0.8 → 0.0.9

data/test/test_poscar.rb

@@ -11,199 +11,199 @@ gem "crystalcell"
 require "crystalcell/cell.rb"
 
 class TC_Poscar < Test::Unit::TestCase
-	$tolerance = 10 ** (-10)
+  $tolerance = 10 ** (-10)
 
-	def test_dump
-		# 例外ケース
-		axes = LatticeAxes.new( [
-			[1.0, 0.0, 0.0 ],
-			[0.0, 1.0, 0.0 ],
-			[0.0, 0.0, 1.0 ],
-			])
-		atoms = [
-			Atom.new(0, [0.1, 0.2, 0.3]),
-			Atom.new(1, [0.2, 0.3, 0.4]),
-			Atom.new(0, [0.3, 0.4, 0.5]),
-		]
-		cell = Cell.new(axes, atoms)
-		cell.comment = "test"
-		io = StringIO.new
-		assert_raises(Poscar::ElementMismatchError){
-			Poscar.dump(cell, [0,1,2], io)}
+  def test_dump
+    # 例外ケース
+    axes = LatticeAxes.new( [
+      [1.0, 0.0, 0.0 ],
+      [0.0, 1.0, 0.0 ],
+      [0.0, 0.0, 1.0 ],
+      ])
+    atoms = [
+      Atom.new(0, [0.1, 0.2, 0.3]),
+      Atom.new(1, [0.2, 0.3, 0.4]),
+      Atom.new(0, [0.3, 0.4, 0.5]),
+    ]
+    cell = Cell.new(axes, atoms)
+    cell.comment = "test"
+    io = StringIO.new
+    assert_raises(Poscar::ElementMismatchError){
+      Poscar.dump(cell, [0,1,2], io)}
 
-		# 生成
-		axes = LatticeAxes.new( [
-			[1.0, 0.0, 0.0 ],
-			[0.0, 1.0, 0.0 ],
-			[0.0, 0.0, 1.0 ],
-			])
-		atoms = [
-			Atom.new(0, [0.1, 0.2, 0.3]),
-			Atom.new(1, [0.2, 0.3, 0.4]),
-			Atom.new(0, [0.3, 0.4, 0.5]),
-		]
-		cell = Cell.new(axes, atoms)
-		cell.comment = "test"
-		io = StringIO.new
-		Poscar.dump(cell, [0,1], io)
-		io.rewind
-		corrects = [
-			"test\n",
-			"1.0\n",
-			"   1.000000000000000   0.000000000000000   0.000000000000000\n",
-			"   0.000000000000000   1.000000000000000   0.000000000000000\n",
-			"   0.000000000000000   0.000000000000000   1.000000000000000\n",
-			"2 1\n",
-			"Direct\n",
-			"   0.100000000000000   0.200000000000000   0.300000000000000\n",
-			"   0.300000000000000   0.400000000000000   0.500000000000000\n",
-			"   0.200000000000000   0.300000000000000   0.400000000000000\n",
-		]
-		lines = io.readlines
-		corrects.each_with_index do |cor, index|
-			assert_equal(cor, lines[index], "line: #{index}")
-		end
-		assert_equal(corrects.size, lines.size)
+    # 生成
+    axes = LatticeAxes.new( [
+      [1.0, 0.0, 0.0 ],
+      [0.0, 1.0, 0.0 ],
+      [0.0, 0.0, 1.0 ],
+      ])
+    atoms = [
+      Atom.new(0, [0.1, 0.2, 0.3]),
+      Atom.new(1, [0.2, 0.3, 0.4]),
+      Atom.new(0, [0.3, 0.4, 0.5]),
+    ]
+    cell = Cell.new(axes, atoms)
+    cell.comment = "test"
+    io = StringIO.new
+    Poscar.dump(cell, [0,1], io)
+    io.rewind
+    corrects = [
+      "test\n",
+      "1.0\n",
+      "   1.000000000000000   0.000000000000000   0.000000000000000\n",
+      "   0.000000000000000   1.000000000000000   0.000000000000000\n",
+      "   0.000000000000000   0.000000000000000   1.000000000000000\n",
+      "2 1\n",
+      "Direct\n",
+      "   0.100000000000000   0.200000000000000   0.300000000000000\n",
+      "   0.300000000000000   0.400000000000000   0.500000000000000\n",
+      "   0.200000000000000   0.300000000000000   0.400000000000000\n",
+    ]
+    lines = io.readlines
+    corrects.each_with_index do |cor, index|
+      assert_equal(cor, lines[index], "line: #{index}")
+    end
+    assert_equal(corrects.size, lines.size)
 
-		atoms = [
-			Atom.new(0, [0.1, 0.2, 0.3], "atom0", [false, true , true ]),
-			Atom.new(1, [0.2, 0.3, 0.4], "atom1", [false, false, true ]),
-			Atom.new(0, [0.3, 0.4, 0.5], "atom2", [false, false, false]),
-		]
-		cell = Cell.new(axes, atoms)
-		cell.comment = "test"
-		io = StringIO.new
-		Poscar.dump(cell, [0,1], io)
-		io.rewind
-		corrects = [
-			"test\n",
-			"1.0\n",
-			"   1.000000000000000   0.000000000000000   0.000000000000000\n",
-			"   0.000000000000000   1.000000000000000   0.000000000000000\n",
-			"   0.000000000000000   0.000000000000000   1.000000000000000\n",
-			"2 1\n",
-			"Selective dynamics\n",
-			"Direct\n",
-			"   0.100000000000000   0.200000000000000   0.300000000000000 F T T\n",
-			"   0.300000000000000   0.400000000000000   0.500000000000000 F F F\n",
-			"   0.200000000000000   0.300000000000000   0.400000000000000 F F T\n",
-		]
-		lines = io.readlines
-		corrects.each_with_index do |cor, index|
-			assert_equal(cor, lines[index], "line: #{index}")
-		end
-		assert_equal(corrects.size, lines.size)
-	end
+    atoms = [
+      Atom.new(0, [0.1, 0.2, 0.3], "atom0", [false, true , true ]),
+      Atom.new(1, [0.2, 0.3, 0.4], "atom1", [false, false, true ]),
+      Atom.new(0, [0.3, 0.4, 0.5], "atom2", [false, false, false]),
+    ]
+    cell = Cell.new(axes, atoms)
+    cell.comment = "test"
+    io = StringIO.new
+    Poscar.dump(cell, [0,1], io)
+    io.rewind
+    corrects = [
+      "test\n",
+      "1.0\n",
+      "   1.000000000000000   0.000000000000000   0.000000000000000\n",
+      "   0.000000000000000   1.000000000000000   0.000000000000000\n",
+      "   0.000000000000000   0.000000000000000   1.000000000000000\n",
+      "2 1\n",
+      "Selective dynamics\n",
+      "Direct\n",
+      "   0.100000000000000   0.200000000000000   0.300000000000000 F T T\n",
+      "   0.300000000000000   0.400000000000000   0.500000000000000 F F F\n",
+      "   0.200000000000000   0.300000000000000   0.400000000000000 F F T\n",
+    ]
+    lines = io.readlines
+    corrects.each_with_index do |cor, index|
+      assert_equal(cor, lines[index], "line: #{index}")
+    end
+    assert_equal(corrects.size, lines.size)
+  end
 
-	def test_parse
-		io = StringIO.new
-		assert_raises(Poscar::ParseError){ Poscar.parse(io) }
+  def test_parse
+    io = StringIO.new
+    assert_raises(Poscar::ParseError){ Poscar.parse(io) }
 
-		io = StringIO.new
-		io.puts "sample0"
-		io.puts "1.0"
-		io.puts "    1.0  0.0  0.0"
-		io.puts "    0.0  1.0  0.0"
-		io.puts "    0.0  0.0  1.0"
-		io.puts " 1 1 1"
-		io.puts "Direct"
-		io.puts "    0.0  0.0  0.0  #Li-001"
-		io.puts "    0.5  0.0  0.0  #Ge-002"
-		io.puts "    0.5  0.5  0.0  #O--003"
-		io.rewind
-		cell = Poscar.parse(io)
-		assert_equal("sample0", cell.comment)
-		assert_equal(
-			LatticeAxes.new( [
-				[1.0, 0.0, 0.0 ],
-				[0.0, 1.0, 0.0 ],
-				[0.0, 0.0, 1.0 ],
-			]),
-			cell.axes
-		)
-		assert_equal(
-			Atom.new(0, [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
-		assert_equal(
-			Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
-		assert_equal(
-			Atom.new(2, [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
+    io = StringIO.new
+    io.puts "sample0"
+    io.puts "1.0"
+    io.puts "    1.0  0.0  0.0"
+    io.puts "    0.0  1.0  0.0"
+    io.puts "    0.0  0.0  1.0"
+    io.puts " 1 1 1"
+    io.puts "Direct"
+    io.puts "    0.0  0.0  0.0  #Li-001"
+    io.puts "    0.5  0.0  0.0  #Ge-002"
+    io.puts "    0.5  0.5  0.0  #O--003"
+    io.rewind
+    cell = Poscar.parse(io)
+    assert_equal("sample0", cell.comment)
+    assert_equal(
+      LatticeAxes.new( [
+        [1.0, 0.0, 0.0 ],
+        [0.0, 1.0, 0.0 ],
+        [0.0, 0.0, 1.0 ],
+      ]),
+      cell.axes
+    )
+    assert_equal(
+      Atom.new(0, [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
+    assert_equal(
+      Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
+    assert_equal(
+      Atom.new(2, [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
 
-		io = StringIO.new
-		io.puts "sample1"
-		io.puts "2.0"
-		io.puts "    1.0  0.0  0.0"
-		io.puts "    0.0  1.0  0.0"
-		io.puts "    0.0  0.0  1.0"
-		io.puts " 1 1 2"
-		io.puts "Selective dynamics"
-		io.puts "Direct"
-		io.puts "    0.0  0.0  0.0  F F F #Li-001"
-		io.puts "    0.5  0.0  0.0  F T F #Ge-002"
-		io.puts "    0.5  0.5  0.0  T T T #O--003"
-		io.puts "    0.5  0.5  0.5  T T T #O--004"
-		io.rewind
-		cell = Poscar.parse(io)
-		assert_equal("sample1", cell.comment)
-		assert_equal(
-			LatticeAxes.new( [
-				[2.0, 0.0, 0.0 ],
-				[0.0, 2.0, 0.0 ],
-				[0.0, 0.0, 2.0 ],
-			]),
-			cell.axes
-		)
-		assert_equal(
-			Atom.new(0, [0.0, 0.0, 0.0], "#Li-001", [false, false, false]),
-			cell.atoms[0])
-		assert_equal(
-			Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002", [false, true , false]),
-			cell.atoms[1])
-		assert_equal(
-			Atom.new(2, [0.5, 0.5, 0.0], "#O--003", [true, true, true]),
-			cell.atoms[2])
-		assert_equal(
-			Atom.new(2, [0.5, 0.5, 0.5], "#O--004", [true, true, true]),
-			cell.atoms[3])
-	end
+    io = StringIO.new
+    io.puts "sample1"
+    io.puts "2.0"
+    io.puts "    1.0  0.0  0.0"
+    io.puts "    0.0  1.0  0.0"
+    io.puts "    0.0  0.0  1.0"
+    io.puts " 1 1 2"
+    io.puts "Selective dynamics"
+    io.puts "Direct"
+    io.puts "    0.0  0.0  0.0  F F F #Li-001"
+    io.puts "    0.5  0.0  0.0  F T F #Ge-002"
+    io.puts "    0.5  0.5  0.0  T T T #O--003"
+    io.puts "    0.5  0.5  0.5  T T T #O--004"
+    io.rewind
+    cell = Poscar.parse(io)
+    assert_equal("sample1", cell.comment)
+    assert_equal(
+      LatticeAxes.new( [
+        [2.0, 0.0, 0.0 ],
+        [0.0, 2.0, 0.0 ],
+        [0.0, 0.0, 2.0 ],
+      ]),
+      cell.axes
+    )
+    assert_equal(
+      Atom.new(0, [0.0, 0.0, 0.0], "#Li-001", [false, false, false]),
+      cell.atoms[0])
+    assert_equal(
+      Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002", [false, true , false]),
+      cell.atoms[1])
+    assert_equal(
+      Atom.new(2, [0.5, 0.5, 0.0], "#O--003", [true, true, true]),
+      cell.atoms[2])
+    assert_equal(
+      Atom.new(2, [0.5, 0.5, 0.5], "#O--004", [true, true, true]),
+      cell.atoms[3])
+  end
 
-	def test_load_file
-		cell = Poscar.load_file("test/poscar/POSCAR.00")
-		assert_equal("sample0", cell.comment)
-		assert_equal(
-			LatticeAxes.new( [
-				[1.0, 0.0, 0.0 ],
-				[0.0, 1.0, 0.0 ],
-				[0.0, 0.0, 1.0 ],
-			]),
-			cell.axes
-		)
-		assert_equal(
-			Atom.new(0, [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
-		assert_equal(
-			Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
-		assert_equal(
-			Atom.new(2, [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
+  def test_load_file
+    cell = Poscar.load_file("test/poscar/POSCAR.00")
+    assert_equal("sample0", cell.comment)
+    assert_equal(
+      LatticeAxes.new( [
+        [1.0, 0.0, 0.0 ],
+        [0.0, 1.0, 0.0 ],
+        [0.0, 0.0, 1.0 ],
+      ]),
+      cell.axes
+    )
+    assert_equal(
+      Atom.new(0, [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
+    assert_equal(
+      Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
+    assert_equal(
+      Atom.new(2, [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
 
-		#cell = Poscar.load_file("test/poscar/POSCAR.02")
-		#assert_equal("sample0", cell.comment)
-		#assert_in_delta( 7.1028554188641708, cell.axes[0][0], $tolerance)
-		#assert_in_delta(-0.0000000169534433, cell.axes[0][1], $tolerance)
-		#assert_in_delta(-0.0000000169534428, cell.axes[0][2], $tolerance)
-		#assert_in_delta( 0.0000001136137521, cell.axes[1][0], $tolerance) 
-		#assert_in_delta( 7.1028554188641725, cell.axes[1][1], $tolerance) 
-		#assert_in_delta(-0.0000000169534433, cell.axes[1][2], $tolerance) 
-		#assert_in_delta( 0.0000001136137521, cell.axes[2][0], $tolerance) 
-		#assert_in_delta( 0.0000001136137521, cell.axes[2][1], $tolerance) 
-		#assert_in_delta( 7.1028554188641725, cell.axes[2][2], $tolerance) 
-		#assert_equal(0, cell.atoms[0].element)
-		#assert_equal(0.0395891220708791, cell.atoms[0].position[0]) 
-		#assert_equal(0.0395891220708791, cell.atoms[0].position[1])
-		#assert_equal(0.0395891220708791, cell.atoms[0].position[2])
+    #cell = Poscar.load_file("test/poscar/POSCAR.02")
+    #assert_equal("sample0", cell.comment)
+    #assert_in_delta( 7.1028554188641708, cell.axes[0][0], $tolerance)
+    #assert_in_delta(-0.0000000169534433, cell.axes[0][1], $tolerance)
+    #assert_in_delta(-0.0000000169534428, cell.axes[0][2], $tolerance)
+    #assert_in_delta( 0.0000001136137521, cell.axes[1][0], $tolerance) 
+    #assert_in_delta( 7.1028554188641725, cell.axes[1][1], $tolerance) 
+    #assert_in_delta(-0.0000000169534433, cell.axes[1][2], $tolerance) 
+    #assert_in_delta( 0.0000001136137521, cell.axes[2][0], $tolerance) 
+    #assert_in_delta( 0.0000001136137521, cell.axes[2][1], $tolerance) 
+    #assert_in_delta( 7.1028554188641725, cell.axes[2][2], $tolerance) 
+    #assert_equal(0, cell.atoms[0].element)
+    #assert_equal(0.0395891220708791, cell.atoms[0].position[0]) 
+    #assert_equal(0.0395891220708791, cell.atoms[0].position[1])
+    #assert_equal(0.0395891220708791, cell.atoms[0].position[2])
 
-	end
+  end
 
-	#def setup
-	#	#@pp02 = Poscar.new("test/poscar/POSCAR.shirai")
-	#end
+  #def setup
+  # #@pp02 = Poscar.new("test/poscar/POSCAR.shirai")
+  #end
 
 end

data/test/test_potcar.rb

@@ -5,61 +5,61 @@ require "vasputils/potcar.rb"
 
 class TC_Potcar < Test::Unit::TestCase
 
-	def setup
-		@p0 = Potcar.load_file("test/potcar/POTCAR"           )
-		@p1 = Potcar.load_file("test/potcar/POTCAR.dummy"     )
-		@p2 = Potcar.load_file("test/potcar/POTCAR.allElement")
-	end
+  def setup
+    @p0 = Potcar.load_file("test/potcar/POTCAR"           )
+    @p1 = Potcar.load_file("test/potcar/POTCAR.dummy"     )
+    @p2 = Potcar.load_file("test/potcar/POTCAR.allElement")
+  end
 
-	def test_get_filename
-		assert_equal("test/potcar/POTCAR"           , @p0[:name])
-		assert_equal("test/potcar/POTCAR.dummy"     , @p1[:name])
-		assert_equal("test/potcar/POTCAR.allElement", @p2[:name])
-	end
+  def test_get_filename
+    assert_equal("test/potcar/POTCAR"           , @p0[:name])
+    assert_equal("test/potcar/POTCAR.dummy"     , @p1[:name])
+    assert_equal("test/potcar/POTCAR.allElement", @p2[:name])
+  end
 
-	def test_elements
-		assert_equal([ "Li", "Ge", "O" ], @p0[:elements])
-		assert_equal([ "Li", "Ge", "O" ], @p1[:elements])
-		correct = [
-			"Ac", "Ac", "Ag", "Al", "Al", "Ar", "As", "Au", "B", "B", "B", "Ba",
-			"Be", "Be", "Bi", "Bi", "Br", "C", "C", "C", "Ca", "Ca", "Cd", "Ce",
-			"Ce", "Cl", "Cl", "Co", "Cr", "Cr", "Cs", "Cu", "Cu", "Dy",
-			"Er", "Er", "Eu", "Eu", "F", "F", "F", "Fe", "Fe", "Ga", "Ga", "Ga",
-			"Gd", "Gd", "Ge", "Ge", "Ge", "H", "H", "H", "H", "H", "H", "He",
-			"Hf", "Hf", "Hg", "Ho", "I", "In", "In", "Ir", "K", "K", "Kr",
-			"La", "La", "Li", "Li", "Lu", "Lu", "Mg", "Mg", "Mn", "Mn",
-			"Mo", "Mo", "N", "N", "N", "Na", "Na", "Na", "Nb", "Nb", "Nd", "Nd",
-			"Ne", "Ni", "Ni", "Np", "Np", "O", "O", "O", "Os", "Os", "P", "P",
-			"Pa", "Pa", "Pb", "Pb", "Pd", "Pd", "Pm", "Pm", "Pr", "Pr", "Pt",
-			"Pu", "Pu", "Rb", "Rb", "Re", "Re", "Rh", "Rh", "Ru", "Ru", "S", "S",
-			"Sb", "Sc", "Se", "Si", "Si", "Sm", "Sm", "Sn", "Sn", "Sr",
-			"Ta", "Ta", "Tb", "Tc", "Tc", "Te", "Th", "Th", "Ti", "Ti", "Ti",
-			"Tl", "Tl", "Tm", "Tm", "U", "U", "V", "V", "V", "W", "W", "X", "Y",
-			"Yb", "Yb", "Zn", "Zr", "Zr"]
-		assert_equal( correct, @p2[:elements])
-	end
+  def test_elements
+    assert_equal([ "Li", "Ge", "O" ], @p0[:elements])
+    assert_equal([ "Li", "Ge", "O" ], @p1[:elements])
+    correct = [
+      "Ac", "Ac", "Ag", "Al", "Al", "Ar", "As", "Au", "B", "B", "B", "Ba",
+      "Be", "Be", "Bi", "Bi", "Br", "C", "C", "C", "Ca", "Ca", "Cd", "Ce",
+      "Ce", "Cl", "Cl", "Co", "Cr", "Cr", "Cs", "Cu", "Cu", "Dy",
+      "Er", "Er", "Eu", "Eu", "F", "F", "F", "Fe", "Fe", "Ga", "Ga", "Ga",
+      "Gd", "Gd", "Ge", "Ge", "Ge", "H", "H", "H", "H", "H", "H", "He",
+      "Hf", "Hf", "Hg", "Ho", "I", "In", "In", "Ir", "K", "K", "Kr",
+      "La", "La", "Li", "Li", "Lu", "Lu", "Mg", "Mg", "Mn", "Mn",
+      "Mo", "Mo", "N", "N", "N", "Na", "Na", "Na", "Nb", "Nb", "Nd", "Nd",
+      "Ne", "Ni", "Ni", "Np", "Np", "O", "O", "O", "Os", "Os", "P", "P",
+      "Pa", "Pa", "Pb", "Pb", "Pd", "Pd", "Pm", "Pm", "Pr", "Pr", "Pt",
+      "Pu", "Pu", "Rb", "Rb", "Re", "Re", "Rh", "Rh", "Ru", "Ru", "S", "S",
+      "Sb", "Sc", "Se", "Si", "Si", "Sm", "Sm", "Sn", "Sn", "Sr",
+      "Ta", "Ta", "Tb", "Tc", "Tc", "Te", "Th", "Th", "Ti", "Ti", "Ti",
+      "Tl", "Tl", "Tm", "Tm", "U", "U", "V", "V", "V", "W", "W", "X", "Y",
+      "Yb", "Yb", "Zn", "Zr", "Zr"]
+    assert_equal( correct, @p2[:elements])
+  end
 
-	#def test_self_elements
-	#	assert_equal([ "Li", "Ge", "O" ], Potcar.elements( @p0 ))
-	#	assert_equal([ "Li", "Ge", "O" ], Potcar.elements( @p1 ))
-	#	correct = [
-	#		"Ac", "Ac", "Ag", "Al", "Al", "Ar", "As", "Au", "B", "B", "B", "Ba",
-	#		"Be", "Be", "Bi", "Bi", "Br", "C", "C", "C", "Ca", "Ca", "Cd", "Ce",
-	#		"Ce", "Cl", "Cl", "Co", "Cr", "Cr", "Cs", "Cu", "Cu", "Dy",
-	#		"Er", "Er", "Eu", "Eu", "F", "F", "F", "Fe", "Fe", "Ga", "Ga", "Ga",
-	#		"Gd", "Gd", "Ge", "Ge", "Ge", "H", "H", "H", "H", "H", "H", "He",
-	#		"Hf", "Hf", "Hg", "Ho", "I", "In", "In", "Ir", "K", "K", "Kr",
-	#		"La", "La", "Li", "Li", "Lu", "Lu", "Mg", "Mg", "Mn", "Mn",
-	#		"Mo", "Mo", "N", "N", "N", "Na", "Na", "Na", "Nb", "Nb", "Nd", "Nd",
-	#		"Ne", "Ni", "Ni", "Np", "Np", "O", "O", "O", "Os", "Os", "P", "P",
-	#		"Pa", "Pa", "Pb", "Pb", "Pd", "Pd", "Pm", "Pm", "Pr", "Pr", "Pt",
-	#		"Pu", "Pu", "Rb", "Rb", "Re", "Re", "Rh", "Rh", "Ru", "Ru", "S", "S",
-	#		"Sb", "Sc", "Se", "Si", "Si", "Sm", "Sm", "Sn", "Sn", "Sr",
-	#		"Ta", "Ta", "Tb", "Tc", "Tc", "Te", "Th", "Th", "Ti", "Ti", "Ti",
-	#		"Tl", "Tl", "Tm", "Tm", "U", "U", "V", "V", "V", "W", "W", "X", "Y",
-	#		"Yb", "Yb", "Zn", "Zr", "Zr"]
-	#	assert_equal( correct, Potcar.elements( @p2 ))
-	#end
+  #def test_self_elements
+  # assert_equal([ "Li", "Ge", "O" ], Potcar.elements( @p0 ))
+  # assert_equal([ "Li", "Ge", "O" ], Potcar.elements( @p1 ))
+  # correct = [
+  #   "Ac", "Ac", "Ag", "Al", "Al", "Ar", "As", "Au", "B", "B", "B", "Ba",
+  #   "Be", "Be", "Bi", "Bi", "Br", "C", "C", "C", "Ca", "Ca", "Cd", "Ce",
+  #   "Ce", "Cl", "Cl", "Co", "Cr", "Cr", "Cs", "Cu", "Cu", "Dy",
+  #   "Er", "Er", "Eu", "Eu", "F", "F", "F", "Fe", "Fe", "Ga", "Ga", "Ga",
+  #   "Gd", "Gd", "Ge", "Ge", "Ge", "H", "H", "H", "H", "H", "H", "He",
+  #   "Hf", "Hf", "Hg", "Ho", "I", "In", "In", "Ir", "K", "K", "Kr",
+  #   "La", "La", "Li", "Li", "Lu", "Lu", "Mg", "Mg", "Mn", "Mn",
+  #   "Mo", "Mo", "N", "N", "N", "Na", "Na", "Na", "Nb", "Nb", "Nd", "Nd",
+  #   "Ne", "Ni", "Ni", "Np", "Np", "O", "O", "O", "Os", "Os", "P", "P",
+  #   "Pa", "Pa", "Pb", "Pb", "Pd", "Pd", "Pm", "Pm", "Pr", "Pr", "Pt",
+  #   "Pu", "Pu", "Rb", "Rb", "Re", "Re", "Rh", "Rh", "Ru", "Ru", "S", "S",
+  #   "Sb", "Sc", "Se", "Si", "Si", "Sm", "Sm", "Sn", "Sn", "Sr",
+  #   "Ta", "Ta", "Tb", "Tc", "Tc", "Te", "Th", "Th", "Ti", "Ti", "Ti",
+  #   "Tl", "Tl", "Tm", "Tm", "U", "U", "V", "V", "V", "W", "W", "X", "Y",
+  #   "Yb", "Yb", "Zn", "Zr", "Zr"]
+  # assert_equal( correct, Potcar.elements( @p2 ))
+  #end
 
 end
 

data/test/test_vaspdir.rb

@@ -111,6 +111,16 @@ class TC_VaspDir < Test::Unit::TestCase
     assert_equal("test/vaspdir/finished/OUTCAR", @vd03.outcar[:name])
   end
 
+  def test_poscar
+    t = @vd03.poscar
+    assert_equal(Cell, t.class)
+    assert_in_delta(3.8879999999999999, t.axes[2][2])
+    
+    t = @vd00.poscar
+    assert_equal(Cell, t.class)
+    assert_in_delta(3.8879999999999999, t.axes[2][2])
+  end
+
   def test_contcar
     t = @vd03.contcar
     assert_equal(Cell, t.class)

data/test/test_vaspkpointsfinder.rb

@@ -0,0 +1,25 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "vasputils/vaspkpointsfinder.rb"
+
+class VaspKpointsFinder
+end
+
+class TC_VaspKpointsFinder < Test::Unit::TestCase
+  def setup
+    @vcf00 = VaspKpointsFinder.new "test/vaspkpointsfinder"
+  end
+
+  def test_kpoints
+    corrects = [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64]
+    #assert_equal(corrects, @vcf00.list_encuts)
+  end
+
+end
+
+#  def test_lowest_encut
+#    assert_equal(200, @vcf00.lowest_encut)
+#  end
+

data/test/vaspkpointsfinder/01-01-01/try00/INCAR

@@ -0,0 +1,17 @@
+SYSTEM = Untitled (VASP)
+    PREC = High
+  IBRION = 2
+     NSW = 100
+    ISIF = 3
+   ENCUT = 200
+    NELM = 60
+  NELMIN = 2
+   EDIFF = 1.0e-05
+  EDIFFG = -0.02
+   ISPIN = 2
+   LWAVE = .FALSE.
+  LCHARG = .FALSE.
+  ISMEAR = 0
+   SIGMA = 0.1
+   IALGO = 38
+   LREAL = Auto

data/test/vaspkpointsfinder/01-01-01/try00/KPOINTS

@@ -0,0 +1,6 @@
+Automatic mesh
+0
+Monkhorst
+  1  1  1
+  0.  0.  0.
+

data/test/vaspkpointsfinder/01-01-01/try00/POSCAR

@@ -0,0 +1,8 @@
+(Li)2  (I222) ~ Untitled (VASP)         
+   1.00000000000000     
+    -1.6954338738674965   -1.6954338738674965    1.6954338738674965
+    -1.6954338738674965    1.6954338738674965   -1.6954338738674965
+     1.6954338738674965   -1.6954338738674965   -1.6954338738674965
+   1
+Direct
+  0.0000000000000000  0.0000000000000000  0.0000000000000000

data/vasputils.gemspec

@@ -5,14 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = "vasputils"
-  s.version = "0.0.8"
+  s.version = "0.0.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippei94da"]
-  s.date = "2012-05-29"
+  s.date = "2012-06-06"
   s.description = "This gem provides parsers for some of input and output files for VASP.\n    This will provide support command for computations."
   s.email = "ippei94da@gmail.com"
-  s.executables = ["addVolumeToten.rb", "latticeconstants", "lsvasp", "lsvaspdir", "lsvaspseries", "qsubvasp", "runvasp", "symposcar"]
+  s.executables = ["addVolumeToten.rb", "checkvasp", "latticeconstants", "qsubvasp", "runvasp", "symposcar"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.rdoc"
@@ -25,10 +25,8 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "bin/addVolumeToten.rb",
+    "bin/checkvasp",
     "bin/latticeconstants",
-    "bin/lsvasp",
-    "bin/lsvaspdir",
-    "bin/lsvaspseries",
     "bin/qsubvasp",
     "bin/runvasp",
     "bin/symposcar",
@@ -41,6 +39,7 @@ Gem::Specification.new do |s|
     "lib/vasputils/potcar.rb",
     "lib/vasputils/vaspdir.rb",
     "lib/vasputils/vaspgeomopt.rb",
+    "lib/vasputils/vaspkpointsfinder.rb",
     "memo.txt",
     "test/calcseries/dup_finished/try00/CONTCAR",
     "test/calcseries/dup_finished/try00/INCAR",
@@ -108,6 +107,7 @@ Gem::Specification.new do |s|
     "test/test_potcar.rb",
     "test/test_vaspdir.rb",
     "test/test_vaspgeomopt.rb",
+    "test/test_vaspkpointsfinder.rb",
     "test/vaspdir/finished/CONTCAR",
     "test/vaspdir/finished/INCAR",
     "test/vaspdir/finished/KPOINTS",
@@ -195,6 +195,10 @@ Gem::Specification.new do |s|
     "test/vaspgeomopt/till01/try01/KPOINTS",
     "test/vaspgeomopt/till01/try01/POSCAR",
     "test/vaspgeomopt/till01/try01/POTCAR",
+    "test/vaspkpointsfinder/01-01-01/try00/INCAR",
+    "test/vaspkpointsfinder/01-01-01/try00/KPOINTS",
+    "test/vaspkpointsfinder/01-01-01/try00/POSCAR",
+    "test/vaspkpointsfinder/01-01-01/try00/POTCAR",
     "vasputils.gemspec"
   ]
   s.homepage = "http://github.com/ippei94da/vasputils"