crysna 0.0.4

data/test/sitesingle/.gitignore

@@ -0,0 +1 @@
+sitesingle.yaml

data/test/sitesingle/sitecombination.yaml

@@ -0,0 +1,29 @@
+---
+'0':
+  Ag:
+  - 2A
+  - 2A
+  I:
+  - IA
+  - IB
+'1':
+  Ag:
+  - 2A
+  - 2B
+  I:
+  - IA
+  - IB
+'2':
+  Ag:
+  - 2B
+  - 2A
+  I:
+  - IA
+  - IB
+'3':
+  Ag:
+  - 2B
+  - 2B
+  I:
+  - IA
+  - IB

data/test/siteuniq/minexpconfiguration.yaml

@@ -0,0 +1,15 @@
+---
+'1':
+  Ag:
+  - 2A
+  - 2B
+  I:
+  - IA
+  - IB
+'2':
+  Ag:
+  - 2A
+  - 2B
+  I:
+  - IA
+  - IB

data/test/siteuniq/siteuniq.yaml

@@ -0,0 +1,8 @@
+---
+'1':
+  Ag:
+  - 2A
+  - 2B
+  I:
+  - IA
+  - IB

data/test/test_atom.rb

@@ -0,0 +1,206 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class TC_Atom < Test::Unit::TestCase
+  def setup
+    #s001 = Crysna::Site.new("A", )
+    @alo000 = Crysna::Atom.new("Li", "A", [0, 0, 0])
+    @alo001 = Crysna::Atom.new("Li", "A", [0, 0, 1])
+    @alo010 = Crysna::Atom.new("Li", "A", [0, 1, 0])
+    @alo100 = Crysna::Atom.new("Li", "A", [1, 0, 0])
+    @alt000 = Crysna::Atom.new("Li", "B", [0, 0, 0])
+    @alt001 = Crysna::Atom.new("Li", "B", [0, 0, 1])
+    @alt010 = Crysna::Atom.new("Li", "B", [0, 1, 0])
+    @alt100 = Crysna::Atom.new("Li", "B", [1, 0, 0])
+    @abo000 = Crysna::Atom.new("Be", "A", [0, 0, 0])
+    @abo001 = Crysna::Atom.new("Be", "A", [0, 0, 1])
+    @abo010 = Crysna::Atom.new("Be", "A", [0, 1, 0])
+    @abo100 = Crysna::Atom.new("Be", "A", [1, 0, 0])
+    @abt000 = Crysna::Atom.new("Be", "B", [0, 0, 0])
+    @abt001 = Crysna::Atom.new("Be", "B", [0, 0, 1])
+    @abt010 = Crysna::Atom.new("Be", "B", [0, 1, 0])
+    @abt100 = Crysna::Atom.new("Be", "B", [1, 0, 0])
+  end
+
+  def test_equal
+    assert_equal(true, @alo000 == Crysna::Atom.new("Li", "A", [0, 0, 0]))
+    assert_equal(true, @alo001 == Crysna::Atom.new("Li", "A", [0, 0, 1]))
+    assert_equal(true, @alo010 == Crysna::Atom.new("Li", "A", [0, 1, 0]))
+    assert_equal(true, @alo100 == Crysna::Atom.new("Li", "A", [1, 0, 0]))
+    assert_equal(true, @alt000 == Crysna::Atom.new("Li", "B", [0, 0, 0]))
+    assert_equal(true, @alt001 == Crysna::Atom.new("Li", "B", [0, 0, 1]))
+    assert_equal(true, @alt010 == Crysna::Atom.new("Li", "B", [0, 1, 0]))
+    assert_equal(true, @alt100 == Crysna::Atom.new("Li", "B", [1, 0, 0]))
+    assert_equal(true, @abo000 == Crysna::Atom.new("Be", "A", [0, 0, 0]))
+    assert_equal(true, @abo001 == Crysna::Atom.new("Be", "A", [0, 0, 1]))
+    assert_equal(true, @abo010 == Crysna::Atom.new("Be", "A", [0, 1, 0]))
+    assert_equal(true, @abo100 == Crysna::Atom.new("Be", "A", [1, 0, 0]))
+    assert_equal(true, @abt000 == Crysna::Atom.new("Be", "B", [0, 0, 0]))
+    assert_equal(true, @abt001 == Crysna::Atom.new("Be", "B", [0, 0, 1]))
+    assert_equal(true, @abt010 == Crysna::Atom.new("Be", "B", [0, 1, 0]))
+    assert_equal(true, @abt100 == Crysna::Atom.new("Be", "B", [1, 0, 0]))
+
+    assert_equal(false, @alo000 == Crysna::Atom.new("Li", "A", [0, 0, 1]))
+    assert_equal(false, @alo000 == Crysna::Atom.new("Li", "A", [0, 1, 0]))
+    assert_equal(false, @alo000 == Crysna::Atom.new("Li", "A", [1, 0, 0]))
+    assert_equal(false, @alo000 == Crysna::Atom.new("Li", "B", [0, 0, 0]))
+    assert_equal(false, @alo000 == Crysna::Atom.new("Be", "A", [0, 0, 0]))
+  end
+
+  #def test_site_name
+  #    assert_equal("A", @alo000.site_name)
+  #    assert_equal("B", @alt000.site_name)
+  #    assert_equal("A", @abo000.site_name)
+  #    assert_equal("B", @abt000.site_name)
+  #end
+
+  def test_migrate!
+    @alo001.migrate!("B", [1, 2, -3])
+    assert_equal( Crysna::Atom.new("Li", "B", [1, 2, -2]), @alo001)
+
+    @abo001.migrate!("B", [1, 2, -3])
+    assert_equal( Crysna::Atom.new("Be", "B", [1, 2, -2]), @abo001)
+  end
+
+  def test_migrate 
+    result = @alo001.migrate("B", [1, 2, -3])
+    assert_equal( Crysna::Atom.new("Li", "A", [0, 0,    1]), @alo001)
+    assert_equal( Crysna::Atom.new("Li", "B", [1, 2, -2]), result)
+  end
+
+  def test_centering!
+    assert_equal(Crysna::Atom.new("Li", "A", [0, 0, 1]), @alo001)
+    @alo001.centering!
+    assert_equal(Crysna::Atom.new("Li", "A", [0, 0, 0]), @alo001)
+  end
+
+  def test_centering
+    assert_equal(Crysna::Atom.new("Li", "A", [0, 0, 0]) , @alo000.centering)
+    assert_equal(Crysna::Atom.new("Li", "A", [0, 0, 0]) , @alo001.centering)
+    assert_equal(Crysna::Atom.new("Li", "A", [0, 0, 0]) , @alo010.centering)
+    assert_equal(Crysna::Atom.new("Li", "A", [0, 0, 0]) , @alo100.centering)
+    assert_equal(Crysna::Atom.new("Li", "B", [0, 0, 0]) , @alt000.centering)
+    assert_equal(Crysna::Atom.new("Li", "B", [0, 0, 0]) , @alt001.centering)
+    assert_equal(Crysna::Atom.new("Li", "B", [0, 0, 0]) , @alt010.centering)
+    assert_equal(Crysna::Atom.new("Li", "B", [0, 0, 0]) , @alt100.centering)
+    assert_equal(Crysna::Atom.new("Be", "A", [0, 0, 0]) , @abo000.centering)
+    assert_equal(Crysna::Atom.new("Be", "A", [0, 0, 0]) , @abo001.centering)
+    assert_equal(Crysna::Atom.new("Be", "A", [0, 0, 0]) , @abo010.centering)
+    assert_equal(Crysna::Atom.new("Be", "A", [0, 0, 0]) , @abo100.centering)
+    assert_equal(Crysna::Atom.new("Be", "B", [0, 0, 0]) , @abt000.centering)
+    assert_equal(Crysna::Atom.new("Be", "B", [0, 0, 0]) , @abt001.centering)
+    assert_equal(Crysna::Atom.new("Be", "B", [0, 0, 0]) , @abt010.centering)
+    assert_equal(Crysna::Atom.new("Be", "B", [0, 0, 0]) , @abt100.centering)
+  end
+
+  def test_compare
+    #equal
+    assert_equal( 0,@alo000 <=> @alo000)
+    assert_equal( 0,@alo001 <=> @alo001)
+    assert_equal( 0,@alo010 <=> @alo010)
+    assert_equal( 0,@alo100 <=> @alo100)
+    assert_equal( 0,@alt000 <=> @alt000)
+    assert_equal( 0,@alt001 <=> @alt001)
+    assert_equal( 0,@alt010 <=> @alt010)
+    assert_equal( 0,@alt100 <=> @alt100)
+    assert_equal( 0,@abo000 <=> @abo000)
+    assert_equal( 0,@abo001 <=> @abo001)
+    assert_equal( 0,@abo010 <=> @abo010)
+    assert_equal( 0,@abo100 <=> @abo100)
+    assert_equal( 0,@abt000 <=> @abt000)
+    assert_equal( 0,@abt001 <=> @abt001)
+    assert_equal( 0,@abt010 <=> @abt010)
+    assert_equal( 0,@abt100 <=> @abt100)
+
+    #
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Be", "A", [ 0, 0, 0]))
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Mg", "A", [ 0, 0, 0]))
+
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Li", " ", [ 0, 0, 0]))
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Li", "Z", [ 0, 0, 0]))
+
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Li", "A", [ 1, 0, 0]))
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Li", "A", [-1, 0, 0]))
+
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Li", "A", [ 0, 1, 0]))
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Li", "A", [ 0,-1, 0]))
+
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Li", "A", [ 0, 0, 1]))
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Li", "A", [ 0, 0,-1]))
+
+    #Element is stronger than others.
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Be", "Z", [ 1, 1, 1]))
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Mg", " ", [-1,-1,-1]))
+
+    #Sitename is stronger than gloval_vector
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Li", " ", [ 1, 1, 1]))
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Li", "Z", [-1,-1,-1]))
+
+    #Order in coordinates
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Li", "A", [ 1,-1,-1]))
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Li", "A", [-1, 1, 1]))
+
+    assert_equal(-1,@alo000 <=> Crysna::Atom.new("Li", "A", [ 0, 1,-1]))
+    assert_equal( 1,@alo000 <=> Crysna::Atom.new("Li", "A", [ 0,-1, 1]))
+  end
+
+  def test_sitename
+    assert_equal("A", @alo000.sitename)
+    assert_equal("A", @alo001.sitename)
+    assert_equal("A", @alo010.sitename)
+    assert_equal("A", @alo100.sitename)
+    assert_equal("B", @alt000.sitename)
+    assert_equal("B", @alt001.sitename)
+    assert_equal("B", @alt010.sitename)
+    assert_equal("B", @alt100.sitename)
+    assert_equal("A", @abo000.sitename)
+    assert_equal("A", @abo001.sitename)
+    assert_equal("A", @abo010.sitename)
+    assert_equal("A", @abo100.sitename)
+    assert_equal("B", @abt000.sitename)
+    assert_equal("B", @abt001.sitename)
+    assert_equal("B", @abt010.sitename)
+    assert_equal("B", @abt100.sitename)
+    assert_equal("B", Crysna::Atom.new("Be", "B", [1, -1, 0]).sitename)
+  end
+
+  def test_full_sitename
+    assert_equal("A555", @alo000.full_sitename)
+    assert_equal("A556", @alo001.full_sitename)
+    assert_equal("A565", @alo010.full_sitename)
+    assert_equal("A655", @alo100.full_sitename)
+    assert_equal("B555", @alt000.full_sitename)
+    assert_equal("B556", @alt001.full_sitename)
+    assert_equal("B565", @alt010.full_sitename)
+    assert_equal("B655", @alt100.full_sitename)
+    assert_equal("A555", @abo000.full_sitename)
+    assert_equal("A556", @abo001.full_sitename)
+    assert_equal("A565", @abo010.full_sitename)
+    assert_equal("A655", @abo100.full_sitename)
+    assert_equal("B555", @abt000.full_sitename)
+    assert_equal("B556", @abt001.full_sitename)
+    assert_equal("B565", @abt010.full_sitename)
+    assert_equal("B655", @abt100.full_sitename)
+    assert_equal("B645", Crysna::Atom.new("Be", "B", [1, -1, 0]).full_sitename)
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/test/test_cell.rb

@@ -0,0 +1,604 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "yaml"
+require "helper"
+#require "test/unit"
+#require "fileutils"
+#require "crystal/latticeaxes.rb"
+#require "crysna/siteconfiguration.rb"
+#require "vasputils/poscar.rb"
+##require "crysna/siteoperation.rb"
+
+class Crysna::Cell
+  attr_accessor :atoms
+end
+
+class TC_Cell < Test::Unit::TestCase
+  def setup
+    @sc00 = Crysna::Cell.new({ 0 => ["A", "B"], 1 => ["C", "D"]})
+    @sc01 = Crysna::Cell.new({ 0 => ["B", "C"], 1 => ["D", "A"]})
+    @sc02 = Crysna::Cell.new( { 3 =>["FS_00"]       , 0 =>["Oc08", "Te00"]})
+    @sc03 = Crysna::Cell.new( { 0 =>["Oc08", "Te14"], 3 =>["FS_00"] })
+    @sc04 = Crysna::Cell.new( { 0 =>["Oc08", "Te00"]})
+    @sc05 = Crysna::Cell.new( { 0 =>["Oc08", "Te14"]})
+  end
+
+  def test_load_file
+    site_conf_file = "tmp_site.conf"
+    FileUtils.rm site_conf_file if File.exist? site_conf_file
+
+    site_conf = {
+      0 => ["A", "B"],
+      1 => ["C", "D"],
+    }
+    File.open(site_conf_file, "w") do |io|
+      YAML.dump(site_conf, io)
+    end
+
+    result = Crysna::Cell.load_file(site_conf_file)
+    correct = Crysna::Cell.new(site_conf)
+    assert_equal(correct, result)
+
+    FileUtils.rm site_conf_file if File.exist? site_conf_file
+  end
+
+  def test_new_elems_sitenames
+    correct = Crysna::Cell.new({ 'Ag' => ["A", "B"], 'I' => ["C", "D"]})
+    result = Crysna::Cell.new_elems_sitenames(
+      {'Ag' => 2, 'I' => 2},
+      ["A", "B", "C", "D"]
+    )
+    #pp(correct, result)
+    assert_equal(correct, result)
+  end
+
+  def test_sites
+    correct = { 0 => ["A", "B"], 1 => ["C", "D"]}
+    assert_equal(correct, @sc00.sites)
+  end
+
+  def test_add_atom
+    @sc00.add_atom(2, "T00", [1,2,-1])
+    assert_equal(Crysna::Atom.new(2, "T00", [1,2,-1]), @sc00.atoms[4])
+
+    setup
+    @sc00.add_atom(1, "B", [0,0,0])
+    assert_equal(Crysna::Atom.new(0, "A", [0,0,0]), @sc00.atoms[0])
+    assert_equal(Crysna::Atom.new(0, "B", [0,0,0]), @sc00.atoms[1])
+    assert_equal(Crysna::Atom.new(1, "B", [0,0,0]), @sc00.atoms[2])
+    assert_equal(Crysna::Atom.new(1, "C", [0,0,0]), @sc00.atoms[3])
+    assert_equal(Crysna::Atom.new(1, "D", [0,0,0]), @sc00.atoms[4])
+
+    setup
+    assert_raise(Crysna::Cell::DuplicateSiteError){
+      @sc00.add_atom(1, "B", [0,0,0], true)
+    }
+
+    setup
+    assert_raise(Crysna::Cell::DuplicateSiteError){
+      @sc00.add_atom(0, "B", [0,0,0], true)
+    }
+  end
+
+  def test_operate
+    sc01 = Crysna::Cell.new({})
+    sc01.atoms[0] = Crysna::Atom.new(0, "A", [ 0, 0, 1])
+    sc01.atoms[1] = Crysna::Atom.new(1, "B", [ 0, 1, 0])
+    sc01.atoms[2] = Crysna::Atom.new(2, "C", [ 1, 0, 0])
+    sc01.atoms[3] = Crysna::Atom.new(3, "D", [ 1,-1, 1])
+
+    #Identical operation
+    rotation = [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ]
+    operations = {
+      "A" => ["A", [ 0, 0, 0], rotation],
+      "B" => ["B", [ 0, 0, 0], rotation],
+      "C" => ["C", [ 0, 0, 0], rotation],
+      "D" => ["D", [ 0, 0, 0], rotation],
+    }
+    results = sc01.operate(operations)
+    assert_equal(Crysna::Cell, results.class)
+    atoms = results.atoms
+    assert_equal(Crysna::Atom.new(0, "A", [ 0, 0, 1]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "B", [ 0, 1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(2, "C", [ 1, 0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(3, "D", [ 1,-1, 1]), atoms.shift)
+    assert_equal(nil                                 , atoms.shift)
+
+    #Change names
+    rotation = [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ]
+    operations = {
+      "A" => ["B", [ 0, 0, 0], rotation],
+      "B" => ["C", [ 0, 0, 0], rotation],
+      "C" => ["D", [ 0, 0, 0], rotation],
+      "D" => ["A", [ 0, 0, 0], rotation],
+    }
+    results = sc01.operate(operations)
+    assert_equal(Crysna::Cell, results.class)
+    atoms = results.atoms
+    assert_equal(Crysna::Atom.new(0, "B", [ 0, 0, 1]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "C", [ 0, 1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(2, "D", [ 1, 0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(3, "A", [ 1,-1, 1]), atoms.shift)
+    assert_equal(nil                                 , atoms.shift)
+
+    #Change shift_vector
+    rotation = [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ]
+    operations = {
+      "A" => ["A", [ 0, 1,-1], rotation],
+      "B" => ["B", [ 1,-1, 0], rotation],
+      "C" => ["C", [ 0, 1, 0], rotation],
+      "D" => ["D", [ 1, 1,-1], rotation],
+    }
+    results = sc01.operate(operations)
+    assert_equal(Crysna::Cell, results.class)
+    atoms = results.atoms
+    assert_equal(Crysna::Atom.new(0, "A", [ 0, 1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "B", [ 1, 0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(2, "C", [ 1, 1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(3, "D", [ 2, 0, 0]), atoms.shift)
+    assert_equal(nil                                 , atoms.shift)
+
+    #Change rotation
+    rotation = [
+      [ 0, 1, 0],
+      [-1, 0, 0],
+      [ 0, 0, 1],
+    ]
+    operations = {
+      "A" => ["A", [ 0, 0, 0], rotation],
+      "B" => ["B", [ 0, 0, 0], rotation],
+      "C" => ["C", [ 0, 0, 0], rotation],
+      "D" => ["D", [ 0, 0, 0], rotation],
+    }
+    results = sc01.operate(operations)
+    assert_equal(Crysna::Cell, results.class)
+    atoms = results.atoms
+    assert_equal(Crysna::Atom.new(0, "A", [ 0, 0, 1]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "B", [ 1, 0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(2, "C", [ 0,-1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(3, "D", [-1,-1, 1]), atoms.shift)
+    assert_equal(nil                                 , atoms.shift)
+
+    #Change shift_vector and rotation
+    rotation = [
+      [ 0, 1, 0],
+      [-1, 0, 0],
+      [ 0, 0, 1],
+    ]
+    operations = {
+      "A" => ["A", [ 0, 1,-1], rotation],
+      "B" => ["B", [ 1,-1, 0], rotation],
+      "C" => ["C", [ 0, 1, 0], rotation],
+      "D" => ["D", [ 1, 1,-1], rotation],
+    }
+    results = sc01.operate(operations)
+    assert_equal(Crysna::Cell, results.class)
+    atoms = results.atoms
+    assert_equal(Crysna::Atom.new(0, "A", [ 0, 1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "B", [ 2,-1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(2, "C", [ 0, 0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(3, "D", [ 0, 0, 0]), atoms.shift)
+    assert_equal(nil                                 , atoms.shift)
+
+    #Change name, shift_vector and rotation
+    rotation = [
+      [ 0, 1, 0],
+      [-1, 0, 0],
+      [ 0, 0, 1],
+    ]
+    operations = {
+      "A" => ["B", [ 0, 1,-1], rotation],
+      "B" => ["C", [ 1,-1, 0], rotation],
+      "C" => ["D", [ 0, 1, 0], rotation],
+      "D" => ["E", [ 1, 1,-1], rotation],
+    }
+    results = sc01.operate(operations)
+    assert_equal(Crysna::Cell, results.class)
+    atoms = results.atoms
+    assert_equal(Crysna::Atom.new(0, "B", [ 0, 1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "C", [ 2,-1, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(2, "D", [ 0, 0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(3, "E", [ 0, 0, 0]), atoms.shift)
+    assert_equal(nil                                 , atoms.shift)
+
+    
+    #Raise error
+    operations = {
+      "A" => ["D", rotation],
+      "B" => ["C", rotation],
+      "C" => ["B", rotation],
+    }
+    assert_raise(Crysna::Cell::NoEntryError){sc01.operate(operations)}
+
+    #HERE
+    ##Change name, shift_vector and rotation
+    #sc01 = Crysna::Cell.new({})
+    #sc01.atoms[0] = Crysna::Atom.new(0, "A", [ 0,-1, 0])
+    #rotation = [
+    #    [-1, 0, 0],
+    #    [ 0, 0, 1],
+    #    [ 0, 1, 0],
+    #]
+    #operations = {
+    #    "A" => ["B", [ 0, 1,-1], rotation],
+    #    "B" => ["C", [ 1,-1, 0], rotation],
+    #    "C" => ["D", [ 0, 1, 0], rotation],
+    #    "D" => ["E", [ 1, 1,-1], rotation],
+    #}
+    #results = sc01.operate(operations)
+    #assert_equal(Crysna::Cell, results.class)
+    #atoms = results.atoms
+    #assert_equal(Crysna::Atom.new(0, "B", [ 0, 1, 0]), atoms.shift)
+    #assert_equal(Crysna::Atom.new(1, "C", [ 2,-1, 0]), atoms.shift)
+    #assert_equal(Crysna::Atom.new(2, "D", [ 0, 0, 0]), atoms.shift)
+    #assert_equal(Crysna::Atom.new(3, "E", [ 0, 0, 0]), atoms.shift)
+    #assert_equal(nil                                                                         , atoms.shift)
+
+  end
+
+  def test_equal
+    sites = {
+      0 => ["A", "B"],
+      1 => ["C", "D"],
+    }
+    sc01 = Crysna::Cell.new(sites)
+    assert_equal(true, @sc00 == sc01)
+
+    sites = {
+      1 => ["D", "C"],
+      0 => ["B", "A"],
+    }
+    sc01 = Crysna::Cell.new(sites)
+    assert_equal(true, @sc00 == sc01)
+
+    sites = {
+      0 => ["A", "C"],
+      1 => ["D", "D"],
+    }
+    sc01 = Crysna::Cell.new(sites)
+    assert_equal(false, @sc00 == sc01)
+  end
+
+  def test_added_sites
+    corrects = [
+      Crysna::Cell.new(
+        { 0 => ["A", "A", "B"], 1 => ["C", "D"]}),
+      Crysna::Cell.new(
+        { 0 => ["A", "B", "C"], 1 => ["C", "D"]}),
+    ]
+    results = @sc00.added_sites({ 0 => ["A", "C"] })
+    assert_equal(corrects, results)
+
+    corrects = []
+    results = @sc00.added_sites( { 0 => ["A", "C"] } , true)
+    assert_equal(corrects, results)
+
+    corrects = [
+      Crysna::Cell.new(
+        { 0 => ["A", "B", "E"], 1 => ["C", "D"]}),
+    ]
+    results = @sc00.added_sites( { 0 => ["A", "C", "E"] } , true)
+    assert_equal(corrects, results)
+  end
+
+  def test_elements
+    assert_equal([0,1], @sc00.elements)
+    assert_equal([0,1], @sc01.elements)
+    assert_equal([0,3], @sc02.elements)
+    assert_equal([0,3], @sc03.elements)
+  end
+
+  def test_atoms_of_element
+    atom0A = Crysna::Atom.new(0, "A", [0,0,0])
+    atom0B = Crysna::Atom.new(0, "B", [0,0,0])
+    atom0C = Crysna::Atom.new(0, "C", [0,0,0])
+    atom1A = Crysna::Atom.new(1, "A", [0,0,0])
+    atom1B = Crysna::Atom.new(1, "B", [0,0,0])
+    atom1C = Crysna::Atom.new(1, "C", [0,0,0])
+    atom1D = Crysna::Atom.new(1, "D", [0,0,0])
+    assert_equal([atom0A, atom0B], @sc00.atoms_of_element(0))
+    assert_equal([atom1C, atom1D], @sc00.atoms_of_element(1))
+    assert_equal([], @sc00.atoms_of_element(2))
+
+    assert_equal([atom0B, atom0C], @sc01.atoms_of_element(0))
+    assert_equal([atom1A, atom1D], @sc01.atoms_of_element(1))
+    assert_equal([], @sc01.atoms_of_element(2))
+
+
+    atom0a = Crysna::Atom.new(0, "Oc08", [0,0,0])
+    atom0b = Crysna::Atom.new(0, "Te00", [0,0,0])
+    atom3c = Crysna::Atom.new(3, "FS_00", [0,0,0])
+
+    assert_equal([atom0a, atom0b], @sc02.atoms_of_element(0))
+    assert_equal([atom3c], @sc02.atoms_of_element(3))
+  end
+
+  def test_centering
+    bl = Crysna::Cell.new({ 'Ag' => ["Aa", "Bl"], 'I' => ["Ia", "Ib"]})
+    bl.atoms[0].migrate!('Aa', [0,0,1])
+    bl.atoms[2].migrate!('Ia', [1,0,1])
+    assert_equal( "Ag:Aa556-Bl555,I:Ia656-Ib555", bl.configuration_string_full)
+    tmp = bl.centering
+    assert_equal( "Ag:Aa556-Bl555,I:Ia656-Ib555", bl.configuration_string_full)
+    assert_equal( "Ag:Aa555-Bl555,I:Ia555-Ib555", tmp.configuration_string_full)
+
+    #assert_equal(
+    #    Crysna::Cell.new({ 'Ag' => ["Aa", "Bl"], 'I' => ["Ia", "Ib"]}),
+    #    bl.centering
+    #)
+
+  end
+
+  def test_centering!
+    bl = Crysna::Cell.new({ 'Ag' => ["Aa", "Bl"], 'I' => ["Ia", "Ib"]})
+    bl.atoms[0].migrate!('Aa', [0,0,1])
+    bl.atoms[2].migrate!('Ia', [1,0,1])
+    assert_equal( "Ag:Aa556-Bl555,I:Ia656-Ib555", bl.configuration_string_full)
+    bl.centering!
+    assert_equal( "Ag:Aa555-Bl555,I:Ia555-Ib555", bl.configuration_string_full)
+    #assert_equal(
+    #    Crysna::Cell.new({ 'Ag' => ["Aa", "Bl"], 'I' => ["Ia", "Ib"]}),
+    #    bl.centering
+    #)
+    #
+    bt = Crysna::Cell.new({ 'Ag' => ["Aa", "Bt"], 'I' => ["Ia", "Ib"]})
+    bt.atoms[2].migrate!('Ia', [1,0,0])
+    assert_equal( "Ag:Aa555-Bt555,I:Ia655-Ib555", bt.configuration_string_full)
+    bt.centering!
+    assert_equal( "Ag:Aa555-Bt555,I:Ia555-Ib555", bt.configuration_string_full)
+    #assert_equal(
+    #    Crysna::Cell.new({ 'Ag' => ["Aa", "bt"], 'I' => ["Ia", "Ib"]}),
+    #    bt.centering
+    #)
+
+    bo = Crysna::Cell.new({ 'Ag' => ["Aa", "Bo"], 'I' => ["Ia", "Ib"]})
+    assert_equal( "Ag:Aa555-Bo555,I:Ia555-Ib555", bo.configuration_string_full)
+    bo.centering!
+    assert_equal( "Ag:Aa555-Bo555,I:Ia555-Ib555", bo.configuration_string_full)
+    #assert_equal(
+    #    Crysna::Cell.new({ 'Ag' => ["Aa", "bo"], 'I' => ["Ia", "Ib"]}),
+    #    bo.centering
+    #)
+  end
+
+
+  def test_compare
+#        # 原子数が少ない。
+#        sites = {
+#            0 => ["A", "B"],
+#            1 => ["C"]
+#        }
+#        sc01 = Crysna::Cell.new(sites)
+#        assert_equal(-1, sc01    <=> @sc00)
+#        assert_equal( 1, @sc00 <=> sc01 )
+#
+#        # 原子数が同じで、元素が違う。
+#        sites = { 0 => ["A", "B"], 2 => ["C", "D"] }
+#        sc01 = Crysna::Cell.new(sites)
+#        #pp sc01
+#        #pp @sc00
+#        assert_equal(-1, sc01  <=> @sc00)
+#        assert_equal( 1, @sc00 <=> sc01 )
+#
+#        # 原子、元素、同じで、占有サイトが違う。
+#        sites = { 0 => ["A", "B"], 1 => ["C", "E"] }
+#        sc01 = Crysna::Cell.new(sites)
+#        assert_equal( 1, sc01    <=> @sc00)
+#        assert_equal(-1, @sc00 <=> sc01 )
+#
+#        # 等しい。
+#        sites = { 0 => ["A", "B"], 1 => ["C", "D"] }
+#        sc01 = Crysna::Cell.new(sites)
+#        assert_equal( 0, sc01    <=> @sc00)
+#        assert_equal( 0, @sc00 <=> sc01 )
+#
+#
+#        # 順序が違うもの
+#        assert_equal(-1, @sc02 <=> @sc03)
+#
+#        # 複雑なもの
+#        sc02 = Crysna::Cell.new(
+#            {3=> ["FS_00", "FS_01", "FS_02", "FS_03", "FS_04", "FS_05", "FS_06",
+#                  "FS_07", "FS_08", "FS_09", "FS_10", "FS_11", "FS_12", "FS_13",
+#                  "FS_14", "FS_15"],
+#             0=>["Oc08", "Te00"],
+#             1=>["Oc00", "Oc03", "Oc05", "Oc06"],
+#             2=>["Te02", "Te05", "Te09", "Te12"]
+#            }
+#        )
+#        sc03 = Crysna::Cell.new(
+#            {0=>["Oc08", "Te14"],
+#             1=>["Oc00", "Oc03", "Oc05", "Oc06"],
+#             2=>["Te02", "Te05", "Te09", "Te12"],
+#             3=> ["FS_00", "FS_01", "FS_02", "FS_03", "FS_04", "FS_05", "FS_06",
+#                  "FS_07", "FS_08", "FS_09", "FS_10", "FS_11", "FS_12", "FS_13",
+#                  "FS_14", "FS_15"]}
+#        )
+#        assert_equal(-1, sc02 <=> sc03)
+#
+#
+#        assert_equal(-1, @sc04 <=> @sc05)
+#        assert_equal( 1, @sc05 <=> @sc04)
+#        assert_equal( 0, @sc04 <=> @sc04)
+#        assert_equal( 0, @sc05 <=> @sc05)
+
+    #operation_id: 23$
+    #Aa[0.0, 0.0, 1.0]$
+    #Bl[0.0, 0.0, 0.0]$
+    #Ia[1.0, 0.0, 1.0]$
+    #Ib[0.0, 0.0, 0.0]$
+    #min is updated$
+    #
+    #operation_id: 26$
+    #Aa[0.0, 0.0, 0.0]$
+    #Bt[0.0, 0.0, 0.0]$
+    #Ia[1.0, 0.0, 0.0]$
+    #Ib[0.0, 0.0, 0.0]$
+    #min is updated$
+    #
+    #operation_id: 48$
+    #Aa[0.0, 0.0, 0.0]$
+    #Bo[0.0, 0.0, 0.0]$
+    #Ia[0.0, 0.0, 0.0]$
+    #Ib[0.0, 0.0, 0.0]$
+    #min is updated$
+    #
+    bl = Crysna::Cell.new({ 'Ag' => ["Aa", "Bl"], 'I' => ["Ia", "Ib"]})
+    bl.atoms[0].migrate!('Aa', [0,0,1])
+    bl.atoms[2].migrate!('Ia', [1,0,1])
+
+    bt = Crysna::Cell.new({ 'Ag' => ["Aa", "Bt"], 'I' => ["Ia", "Ib"]})
+    bt.atoms[2].migrate!('Ia', [1,0,0])
+
+    bo = Crysna::Cell.new({ 'Ag' => ["Aa", "Bo"], 'I' => ["Ia", "Ib"]})
+
+    #pp bl
+    #pp bt
+    #pp bo
+    assert_equal(-1, bl <=> bo)
+    assert_equal(-1, bl <=> bt)
+    assert_equal(-1, bo <=> bt)
+  end
+
+#    def test_comparable
+#        sites = {
+#            0 => ["A", "B"],
+#            1 => ["C", "D", "E"],
+#        }
+#        sc01 = Crysna::Cell.new(sites)
+#        tmp = [sc01, @sc00,].sort
+#        assert_equal(@sc00, tmp[0])
+#        assert_equal( sc01, tmp[1])
+#
+#        tmp = [sc01, @sc00,].min
+#        assert_equal(@sc00, tmp)
+#    end
+
+  #def test_min_operation
+  #    rotation = [
+  #        [1, 0, 0],
+  #        [0, 1, 0],
+  #        [0, 0, 1],
+  #    ]
+  #    vector = [0,0,0]
+  #    operations = [{
+  #        "A" => ["B", vector, rotation],
+  #        "B" => ["A", vector, rotation],
+  #        "C" => ["D", vector, rotation],
+  #        "D" => ["C", vector, rotation],
+  #        }, {
+  #        "A" => ["R03", vector, rotation],
+  #        "B" => ["R02", vector, rotation],
+  #        "C" => ["R01", vector, rotation],
+  #        "D" => ["R00", vector, rotation],
+  #        }
+  #    ]
+  #    assert_equal(1, @sc00.min_operation(operations))
+  #end
+
+  def test_minimize
+    rotation = [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ]
+    vector = [0,0,0]
+    operations = [
+      {
+        "operation_id"=>0,
+        "operation"=> {
+          "A" => ["A", vector, rotation],
+          "B" => ["B", vector, rotation],
+          "C" => ["C", vector, rotation],
+          "D" => ["D", vector, rotation],
+          "E" => ["E", vector, rotation],
+          "F" => ["F", vector, rotation],
+        }
+      }, {
+        "operation_id"=>1,
+        "operation"=> {
+          "A" => ["F", vector, rotation],
+          "B" => ["A", vector, rotation],
+          "C" => ["B", vector, rotation],
+          "D" => ["C", vector, rotation],
+          "E" => ["D", vector, rotation],
+          "F" => ["E", vector, rotation],
+        }
+      }
+    ]
+    assert_equal(@sc00, @sc00.minimize(operations))
+
+    correct = Crysna::Cell.new({ 0 => ["A", "B"], 1 => ["C", "F"]})
+    assert_equal(correct, @sc01.minimize(operations))
+
+
+
+  end
+
+  def test_to_yaml
+    assert_equal(
+      { 0 => ["A", "B"], 1 => ["C", "D"]},
+      YAML.load(@sc00.to_yaml)
+    )
+  end
+
+  def test_to_cell
+    axes = CrystalCell::LatticeAxes.new([
+      [2.0, 0.0, 0.0],
+      [0.0, 2.0, 0.0],
+      [0.0, 0.0, 2.0],
+    ])
+    sites_coordinates = {
+      "A" => [0.00, 0.00, 0.00],
+      "B" => [0.00, 0.00, 0.25],
+      "C" => [0.00, 0.00, 0.50],
+      "D" => [0.00, 0.00, 0.75],
+    }
+    result = @sc00.to_cell(axes, sites_coordinates)
+    assert_equal(axes, result.axes)
+    atom = result.atoms[0]
+    assert_equal(0, atom.element)
+    assert_equal(Mageo::Vector3DInternal[0.00, 0.00, 0.00], atom.position)
+    atom = result.atoms[1]
+    assert_equal(0, atom.element)
+    assert_equal(Mageo::Vector3DInternal[0.00, 0.00, 0.25], atom.position)
+    atom = result.atoms[2]
+    assert_equal(1, atom.element)
+    assert_equal(Mageo::Vector3DInternal[0.00, 0.00, 0.50], atom.position)
+    atom = result.atoms[3]
+    assert_equal(1, atom.element)
+    assert_equal(Mageo::Vector3DInternal[0.00, 0.00, 0.75], atom.position)
+  end
+
+  def test_index
+    assert_equal(Crysna::Atom.new(0, "A", [0,0,0]), @sc00[0])
+    assert_equal(Crysna::Atom.new(0, "B", [0,0,0]), @sc00[1])
+    assert_equal(Crysna::Atom.new(1, "C", [0,0,0]), @sc00[2])
+    assert_equal(Crysna::Atom.new(1, "D", [0,0,0]), @sc00[3])
+  end
+
+  def test_configuration_string
+    assert_equal("0:A-B,1:C-D", @sc00.configuration_string)
+    assert_equal("0:B-C,1:A-D", @sc01.configuration_string)
+  end
+
+  def test_configuration_string_full
+    assert_equal("0:A555-B555,1:C555-D555", @sc00.configuration_string_full)
+    assert_equal("0:B555-C555,1:A555-D555", @sc01.configuration_string_full)
+  end
+
+end
+