crystalcell 0.0.0

data/lib/crystalcell/latticeaxes.rb

@@ -0,0 +1,210 @@
+require "rubygems"
+gem "mageo"
+require "mageo/vector3d.rb"
+require "mageo/vector3dinternal.rb"
+require "mageo/axes.rb"
+gem "malge"
+require "malge/simultaneousequations.rb"
+
+# Class to deal with lattice axes in three dimensional space,
+# related to cell parameter and crystal axes.
+# Lattice information cannot be changed after initialized. 
+# 
+# When lattice axes of three vectors are given,
+# lattice axes are automatically converted as below.
+# 	- c axes in internal axis is along to z axis in cartesian axis.
+# 	- b axes in internal axis is on the b-c plane.
+# 	- a axes in internal axis is set to be a right-hand system.
+# 	E.g., 
+# 		[ [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5] ]
+# 		will be converted to 
+# 		[ [0.57735, 0.20412, 0.35355],
+# 			[0.00000, 0.61237, 0.35355],
+# 			[0.00000, 0.00000, 0.70710]]
+class LatticeAxes < Axes
+
+	class InitializeError < Exception; end
+	class ArgumentError < Exception; end
+	class TypeError < Exception; end
+
+	include Math
+
+	# Argument 'vectors' is three vectors with the order of a, b, c.
+	# If you want to make LatticeAxes instances from lattice constants,
+	# you should convert to axes with LatticeAxes.lc_to_axes
+	# 任意の向きのベクトルを渡しても、必ず triangulate する。
+	def initialize(vectors)
+		raise InitializeError, "#{vectors.inspect}" unless vectors.size == 3
+
+		if vectors.class == LatticeAxes
+			@axes = vectors
+		else
+			begin
+				vectors = self.class.triangulate(vectors)
+			rescue Vector3D::RangeError
+				raise InitializeError, "#{vectors.inspect}"
+			end
+
+			super(vectors)
+		end
+	end
+
+
+	## Class methods
+
+	# Convert six lattice constants to three axes.
+	# Set true to the argument of 'righthand' if a assumed lattice has righthand axis system.
+	def self.lc_to_axes(lc, righthand = true)
+		raise ArgumentError if (lc.size != 6)
+
+		a = lc[0]
+		b = lc[1]
+		c = lc[2]
+		alpha = (2.0*PI) * lc[3] / 360.0 # radian
+		beta  = (2.0*PI) * lc[4] / 360.0 # radian
+		gamma = (2.0*PI) * lc[5] / 360.0 # radian
+
+		v_c = Vector3D[0.0, 0.0, c]
+		v_b = Vector3D[0.0, b * Math::sin(alpha), b * Math::cos(alpha)]
+		v_a_z = a * Math::cos(beta)
+		v_a_y = (a * (Math::cos(gamma) - Math::cos(alpha) * Math::cos(beta)))/ Math::sin(alpha)
+		v_a_x = Math::sqrt(a**2 - v_a_y**2 - v_a_z**2)
+		v_a_x *= -1.0 if righthand == false
+		v_a = Vector3D[v_a_x, v_a_y, v_a_z]
+		return [v_a, v_b, v_c]
+	end
+
+	# Convert three axes to six lattice constants.
+	def self.axes_to_lc(axes)
+		axes.collect!{|i| Vector3D[*i] }
+		a = axes[0].r
+		b = axes[1].r
+		c = axes[2].r
+		alpha = axes[1].angle_degree(axes[2])
+		beta  = axes[2].angle_degree(axes[0])
+		gamma = axes[0].angle_degree(axes[1])
+		return [ a, b, c, alpha, beta, gamma ]
+	end
+
+	# Return true if the relation of vector order is righthand system.
+	def self.righthand?(axes)
+		axes.map! { |i| Vector3D[*i] }
+		return true if Vector3D.scalar_triple_product(*axes) > 0.0
+		return false
+	end
+
+	# Return true if the relation of vector order is lefthand system.
+	def self.lefthand?(axes)
+		axes.map! { |i| Vector3D[*i] }
+		return true if Vector3D.scalar_triple_product(*axes) < 0.0
+		return false
+	end
+
+	# Convert three axes to three axes with rules below:
+	# 	c axis is along z axis in cartesian system.
+	# 	b axis is on y-z plane in cartesian system.
+	# Return an array of three Vector3D instances.
+	# This class does not convert righthand to lefthand system.
+	# The name of this method 'triangulate' originates from the
+	# matrix indicating the vectors being triangular matrix.
+	#
+	# クラスメソッドは廃止の方向で。
+	# vectors の数をチェックするのは initialize でやるべきことだろうし、
+	# LatticeAxes クラスインスタンス以外で triangulate を使う場面が想像できない。
+	#
+	def self.triangulate(vectors)
+		vectors.map! { |i| Vector3D[*i] }
+		raise InitializeError if self.dependent?(vectors)
+		lc = self.axes_to_lc(vectors)
+		righthand = self.righthand?(vectors)
+		return self.lc_to_axes(lc, righthand)
+	end
+
+	## Instance methods.
+
+	# Get lattice constants in six values.
+	def get_lattice_constants
+		return LatticeAxes.axes_to_lc(@axes)
+	end
+
+	def righthand?
+		self.class.righthand?(@axes)
+	end
+
+	def lefthand?
+		self.class.lefthand?(@axes)
+	end
+
+	# This class is obsoleted. [2011-12-22]
+	## Convert internal coordinates to cartesian coordinates.
+	## Return a Vector3DInternal class instance, which is not a cartesian vector.
+	#def internal2cartesian(internal_coord)
+	#	Vector3DInternal[ *internal_coord ].to_v3d(axes)
+	#end
+
+	# This class is obsoleted. [2011-12-22]
+	## Convert cartesian coordinates to internal coordinates.
+	## Return a Vector3D class instance, which is a cartesian vector.
+	#def cartesian2internal(cartesian_coord)
+	#	#pp cartesian_coord
+	#	Vector3D[ *cartesian_coord ].to_v3di(axes)
+	#end
+
+	# Compare <other> LatticeAxes instance.
+	# <length_ratio> is tolerance of ratio in length of axes.
+	# <angle_tolerance> is tolerance of value in angle between axes.
+	def equal_in_delta?(other, length_ratio, angle_tolerance)
+		length_a = self .get_lattice_constants[0..2]
+		length_b = other.get_lattice_constants[0..2]
+		3.times do |i|
+			return false unless ((length_a[i] - length_b[i]).abs <= length_ratio)
+		end
+
+		angle_a  = self .get_lattice_constants[3..5]
+		angle_b  = other.get_lattice_constants[3..5]
+		3.times do |i|
+			return false unless ((angle_a[i] - angle_b[i]).abs <=  angle_tolerance)
+		end
+		return true
+	end
+
+	def ==(other)
+		3.times do |i|
+			3.times do |j|
+				return false if self[i][j] != other[i][j]
+			end
+		end
+		return true
+	end
+
+	private
+
+	def triangulate
+		#self.class.triangulate(@axes)
+	#	rotate(2, 2, 1)
+	#	rotate(2, 0, 2)
+	#	rotate(1, 2, 1)
+	end
+
+	#private
+
+	## 保持する全ての軸を回転する。
+	## 以下の index は Axes クラス保持している配列における index。
+	## target_index      回転の際の角度を決めるベクトルの
+	## 	self が保持する内部座標軸の index。
+	## center_axis_index 回転の中心軸のベクトルの index in x, y, z。
+	## plane_axis_index) 回転の目的地となる平面を、中心軸と共に構成するベクトルの index
+	## 	in x, y, z。
+	#def rotate(target_index, center_axis_index, plane_axis_index)
+	#	theta = 
+
+	#	axes[target_index]
+	#	
+	#	HERE
+
+	#	self.each do |vector|
+	#		vector
+	#	end
+	#end
+
+end

data/lib/crystalcell/periodiccell.rb

@@ -0,0 +1,277 @@
+#! /usr/bin/env ruby
+
+require "pp"
+require "crystalcell/cell.rb"
+
+# Class for crystal cell with periodic boundary.
+# Coordinates of atoms are kept in the region of 0 <= x_i < 1 of internal coordinate.
+# Written by Ippei Kishida [2010-12-19].
+class PeriodicCell < Cell
+	class TypeError < Exception; end
+
+	def initialize( *args )
+		super( *args )
+		reset_positions_inside
+	end
+
+	#ある内部座標から、別のある座標とそれと周期的に等価な座標への距離が
+	#tolerance 以下のものを探し、条件を満たすセルの方向を配列にまとめて返す。
+	#
+	#内部的に、一度 0以上1未満の座標に変換しようかと思ったが、
+	#境界付近で問題が生じうる。
+	#
+	#周囲 27 セルしか考慮しない。
+	#美しさを求めるならば tolerance を完全に含む大きさのスーパーセルにすべきだが、
+	#実装が面倒なわりに滅多に使われることがなさそうなので。
+	#出力の順番は、上位の要素が小さなものから順。
+	#(距離の短いものから順という考え方もなくはないが。)
+	#
+	#tolerance を省略( = nil を与えれば )、27セルの中にある全ての方向を返す。
+	def directions_within_distance( pos0, pos1, tolerance = nil )
+		if pos0.class != Vector3DInternal
+			raise TypeError, "pos0 is not a Vector3DInternal class instance."
+		end
+		if pos1.class != Vector3DInternal
+			raise TypeError, "pos1 is not a Vector3DInternal class instance."
+		end
+
+		pos0 = pos0.map{ |i| i - i.floor }.to_a.to_v3di
+		pos1 = pos1.map{ |i| i - i.floor }.to_a.to_v3di
+
+		#pp pos0
+
+		results = []
+		(-1).upto(1) do |x|
+			(-1).upto(1) do |y|
+				(-1).upto(1) do |z|
+					shift = Vector3DInternal[ x.to_f, y.to_f, z.to_f ]
+					d = distance( pos0, ( pos1 + shift))
+					#tolerance が nil ならば距離判定なしで登録。
+					#tolerance が非 nil ならばその値で距離判定して登録。
+					if ( ( ! tolerance ) || ( d < tolerance ) )
+						results << [ x, y, z]
+					end
+				end
+			end
+		end
+		return results
+	end
+
+	# 周期性を考慮して、
+	# 1個目の内部座標( pos0 ) から見て、
+	# 一番近い 2個目の内部座標に等価なサイトの属するセルの方向を返す。
+	# 返り値は Vector3DInternal で
+	# 内部座標が 0.0 <= r < 1.0 になっていることを前提とする。
+	# (なお、この外側であってもこの範囲に入るように周期移動する。)
+	# 座標 0.0 付近の境界は計算誤差の為におかしなことになり易いので注意が必要。
+	#
+	# NOTE: nearest_direction というメソッド名はどうかと思う。
+	# nearest_lattice_vector とか？
+	# 良い名前があれば、リファクタリング対象。
+	#
+	# NOTE: 0〜1の外側なら内側に入れる、という処理は混乱し易い。
+	# 例外にした方が良いのではないだろうか。
+	def nearest_direction( pos0, pos1 )
+		if pos0.class != Vector3DInternal
+			raise TypeError,
+			"pos0.class is not a Vector3DInternal"
+		end
+		if pos1.class != Vector3DInternal
+			raise TypeError,
+			"pos1.class is not a Vector3DInternal"
+		end
+
+		pos0 = pos0.map{ |i| i - i.floor }.to_a.to_v3di
+		pos1 = pos1.map{ |i| i - i.floor }.to_a.to_v3di
+
+		#set first value
+		min = distance( pos0, pos1 )
+		result = Vector3DInternal[ 0, 0, 0 ]
+
+		#find
+		(-1).upto(1) do |x|
+			(-1).upto(1) do |y|
+				(-1).upto(1) do |z|
+					shift = Vector3DInternal[ x.to_f, y.to_f, z.to_f ]
+					d = (pos0 - (pos1 + shift)).to_v3d(@axes).r
+
+					if d < min
+						result = Vector3DInternal[ x, y, z]
+						min = d
+					end
+				end
+			end
+		end
+		return result
+	end
+
+	#周期性を考慮し、2つの地点間の最短距離を返す。
+	#pos0, pos1 には内部座標を指定する。
+	#内部的には周囲 3x3x3 のセル中の27地点のうち最も近いものを得る。
+	#旧 minimum_distance
+	def nearest_distance( pos0, pos1 )
+		[pos0, pos1].each_with_index do |pos, index|
+			unless pos.class == Vector3DInternal
+				raise TypeError,
+				"#{index} th argument: #{pos.inspect}, #{pos.class}"
+			end
+		end
+
+		pos0 = Vector3DInternal[* pos0.map{ |i| i - i.floor }]
+		pos1 = Vector3DInternal[* pos1.map{ |i| i - i.floor }]
+		direction = nearest_direction( pos0, pos1 )
+		3.times do |i|
+			pos1[ i ] += direction[ i ]
+		end
+		distance( pos0, pos1 )
+	end
+
+	#条件にマッチした原子間距離を見つけて、端点の内部座標の組を要素とする配列を返す。
+	#返される配列は3重配列になる。
+	#e.g.,
+	#	[
+	#		[ [0.1, 0.1, 0.1], [0.2, 0.2, 0.2] ],
+	#		[ [0.1, 0.1, 0.1], [0.3, 0.4, 0.5] ],
+	#		[ [0.9, 0.9, 0.9], [0.8, 0.8, 0.8] ]
+	#	]
+	#@bonds への登録はしない。
+	#elem0, elem1 は bond の両端の原子の組み合わせを指定。
+	#elem0, elem1 はメソッド内部で反転したものもチェックするので、順序が反対でも同じ結果になる。
+	#O-O のように同じ元素を指定することもでき、
+	#この場合向きの異なる 2つの bond が重複したりしない。
+	#d_min, d_max は距離の範囲を指定する。
+	#境界値そのものが問題になることは少ないだろう。
+	#d_min <= d <= d_max(以上、以下) としておくが、計算誤差のためにこれはほぼ無意味だ。
+	#見つけて配列として返すだけで、登録はしない。
+	#
+	#以下の案は棄却。
+	#	- いかなる元素でもマッチ。
+	#	- 距離の上限を無効。
+	#理由は、
+	#	- プログラムが煩雑になる。
+	#	- 引数の型が統一されない。
+	#	- ほとんど使用する機会がなさそう。
+	#		大抵は元素を指定するし、元素を指定しない bond を描く状況は考えにくい。
+	#		これが必要ならメソッドの外で組み合わせを作ってそれぞれで呼べば良い。
+	#	- 大抵は距離の上限を定めるし、上限なしではハリネズミになるだけ。
+	#		また、プログラム上は距離の上限を 3x3x3 スーパーセルに制限したりするが、
+	#		論理的に距離の上限なしってのは無限のセルを対象にすることになり、整合性がとれない。
+	def find_bonds( elem0, elem1, d_min, d_max )
+		results = []
+		atoms.each do |inner_atom|
+			atoms_in_supercell( -1, 1, -1, 1, -1, 1 ).each do |outer_atom|
+				#元素の種類による判定
+				ie = inner_atom.element
+				oe = outer_atom.element
+				next unless ( (( ie == elem0 ) && ( oe == elem1 )) || (( ie == elem1 ) && ( oe == elem0 ))) #elem0, elem1 と同じ構成
+
+				#距離による判定
+				ip = inner_atom.position
+				op = outer_atom.position
+				next if distance( ip, op ) < d_min
+				next if distance( ip, op ) > d_max
+				next if distance( ip, op ) == 0.0 #同一サイト判定
+
+				#重複判定, 正順か逆順が既に含まれていれば無視。
+				next if ( results.include?( [ ip, op ] ) || results.include?( [ op, ip ] ) )
+
+				results << [ ip, op ]
+			end
+		end
+		return results
+	end
+
+	#引数 distance 以下の間の距離にある原子のペアを列挙して返す。
+	#この際、あくまで unique なものを返し、A-B があれば B-A はリストに含まれない。
+	#
+	#返す形式は以下のような形式。
+	#[ [0, 1, [0, 0, 0], [0, 1, [0, 0, 1] ]
+	#最初の 0, 1 はそれぞれ配列 @atoms 内の番号で、
+	#0番目の原子からから同じセル内の 1番目の原子
+	#0番目の原子からから[0,0,1]方向に隣接するセル内の 1番目の原子を意味する。
+	#起点となる原子の番号と(上記 0 )と目的地の原子の番号(上記 1)が同じこともありうる。
+	#異なる場合は起点となる原子の番号が、目的地の原子の番号より若くなる。
+	#
+	#自分と同じ番号の場合は、同じセルを除外する。
+	#すなわち、[0, 0, [0, 0, 0] や [1, 1, [0, 0, 0] は含まれない。
+	def pairs_within_distance( distance )
+		results = []
+		n_atom = @atoms.size
+		n_atom.times do |i|
+			pos_i = @atoms[i].position
+
+			n_atom.times do |j|
+				pos_j = @atoms[j].position
+
+				directions_within_distance( pos_i, pos_j, distance ).each do |dir|
+					#next if ( i==j && dir==[0,0,0] ) #距離0の自分自身。下の条件に含まれる。
+					next if ( dir==[0,0,0] && i >= j ) #同じセル内は番号が若い方からのみ。
+					results << [ i, j, dir ]
+				end
+			end
+		end
+		return results
+	end
+
+	# Functions as like Cell.add_atom, but the coordinates are converted to the region of 0 <= x_i < 1.
+	def add_atom( *args )
+		super( *args )
+		reset_positions_inside
+	end
+
+	# Functions as like Cell.rotate!, but the coordinates are converted to the region of 0 <= x_i < 1.
+	# Dependent function 'rotate' functions the same.
+	def rotate!( *args )
+		super( *args )
+		reset_positions_inside
+	end
+
+	# Functions as like Cell.translate!, but the coordinates are converted to the region of 0 <= x_i < 1.
+	# Dependent function 'translate' functions the same.
+	def translate!( *args )
+		super( *args )
+		reset_positions_inside
+	end
+
+	# Return a new instance converted to Cell class.
+	def to_cell
+		tmp = Cell.new( @axes.to_a )
+		tmp.comment = self.comment
+		@atoms.each do |atom|
+			tmp.add_atom(atom)
+		end
+		return tmp
+	end
+
+	undef center_of_atoms
+
+	# superclass の inverse_axis! を行ったあと、
+	# 原子の座標をセル内部に移す。
+	def inverse_axis!( axis_id )
+		result = Marshal.load( Marshal.dump( self ) )
+		super( axis_id )
+		reset_positions_inside
+	end
+
+	private
+
+	# Reset internal coordinates of all atoms inside the region of 0 <= x_i < 1.
+	def reset_positions_inside
+		@atoms.each do |atom|
+			coords = atom.position
+			atom.set_position(coords.map {|coord| coord - coord.floor}.to_a.to_v3di)
+		end
+	end
+
+end
+
+class Cell
+	#require "Crystal/PeriodicCell.rb"
+	# Return a new instance converted to PeriodicCell class.
+	def to_pcell
+		atoms = Marshal.load(Marshal.dump(@atoms))
+		result = PeriodicCell.new( @axes.to_a, atoms )
+		result.comment = self.comment
+		return result
+	end
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'crystalcell'
+
+class Test::Unit::TestCase
+end