crysna 0.0.4

data/test/test_commands.rb

@@ -0,0 +1,340 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "fileutils"
+require "helper"
+#require "test/unit"
+#require "crysna/modelcell.rb"
+#require "crysna/frameatom.rb"
+#require "crysna/interstitialatom.rb"
+#require "crysna/frameinterstitialcell.rb"
+#require "vasputils/poscar.rb"
+
+$tolerance = 1.0E-10
+
+class TC_CrysnaCommands < Test::Unit::TestCase
+
+  #def test_optimizedframecell
+  #    TODO
+  #end
+
+
+
+
+
+  ##def setup
+  ## @k = Klass.new
+  ##end
+  ##
+  #TMP_DIR = "test/tmp"
+  #TMP_POSCAR = "#{TMP_DIR}/POSCAR"
+  #TMP_OPTIMIZED_YAML = "#{TMP_DIR}/optimized.yaml"
+  #TMP_MODEL_YAML = "#{TMP_DIR}/model.yaml"
+  #TMP_FILES = [
+  #    TMP_POSCAR,
+  #    TMP_OPTIMIZED_YAML,
+  #    TMP_MODEL_YAML,
+  #    "#{TMP_DIR}/optimized_ficell.yaml",
+  #]
+
+  #def setup
+  #    TMP_FILES.each { |file| FileUtils.rm file if File.exist? file }
+  #    Dir.glob("#{TMP_DIR}/*").each {|file| FileUtils.rm file}
+  #    Dir.rmdir TMP_DIR if Dir.exist? TMP_DIR
+  #    #
+  #    Dir.mkdir TMP_DIR unless Dir.exist? TMP_DIR
+  #    File.open(TMP_POSCAR, "w") do |io|
+  #        io.puts "Model to test optimizeframe command"
+  #        io.puts "1.0"
+  #        io.puts "  2.0  2.0    2.0"
+  #        io.puts "  0.0  2.0    2.0"
+  #        io.puts "  0.0  0.0    2.0"
+  #        io.puts "7 1 2"
+  #        io.puts "Direct"
+  #        io.puts "  0.10    0.10    0.10"
+  #        io.puts "  0.10    0.10    0.11"
+  #        io.puts "  0.10    0.10    0.13"
+  #        io.puts "  0.10    0.12    0.10"
+  #        io.puts "  0.10    0.16    0.10"
+  #        io.puts "  0.13    0.10    0.10"
+  #        io.puts "  0.19    0.10    0.10"
+  #        io.puts "  0.11    0.11    0.11"
+  #        io.puts "  0.00    0.00    0.00"
+  #        io.puts "  0.90    0.90    0.90"
+  #    end
+
+  #    model = {
+  #        "frame_elements" => [ 0 ],
+  #        "frame_sites" => {
+  #            "FS_000"=>[0.00, 0.00, 0.00],
+  #            "FS_001"=>[0.00, 0.00, 0.01],
+  #            "FS_003"=>[0.00, 0.00, 0.03],
+  #            "FS_020"=>[0.00, 0.02, 0.00],
+  #            "FS_060"=>[0.00, 0.06, 0.00],
+  #            "FS_300"=>[0.03, 0.00, 0.00],
+  #            "FS_900"=>[0.09, 0.00, 0.00],
+  #        },
+  #        "symmetry_operations" => [
+  #            {
+  #                "rotation" => [[    1,  0,  0], [  0,  1,  0], [    0,  0,  1]],
+  #                "translation" => [  0.0000000,  0.0000000,  0.0000000]
+  #            }, {
+  #                "rotation" => [ [ -1,  0,  0], [    0, -1,  0], [  0,  0, -1]],
+  #                "translation" => [  0.0000000,  0.0000000,  0.0000000]
+  #            }
+  #        ],
+  #        "octahedral_sites" => {
+  #            "Oc_000"=> [
+  #                [["FS_000", [0, 0, 1]], ["FS_000", [1, 1, 0]]],
+  #                [["FS_000", [0, 1, 0]], ["FS_000", [1, 0, 1]]],
+  #                [["FS_000", [1, 0, 0]], ["FS_000", [0, 1, 1]]]
+  #            ]
+  #        },
+  #        "tetrahedral_sites" => {
+  #            "Te_000"=> [
+  #                ["FS_000", [0, 0, 0]], ["FS_000", [0, 0, 1]],
+  #                ["FS_000", [0, 1, 0]], ["FS_000", [1, 0, 0]]
+  #            ],
+  #            "Te_001"=> [
+  #                ["FS_000", [1, 1, 1]], ["FS_000", [1, 1, 0]],
+  #                ["FS_000", [1, 0, 1]], ["FS_000", [0, 1, 1]]
+  #            ]
+  #        }
+  #    }
+  #    File.open(TMP_MODEL_YAML, "w") do |io|
+  #        YAML.dump(model, io)
+  #    end
+  #end
+
+  #def teardown
+  #    TMP_FILES.each { |file| FileUtils.rm file if File.exist? file }
+  #    Dir.glob("#{TMP_DIR}/*").each {|file| FileUtils.rm file}
+  #    Dir.rmdir TMP_DIR if Dir.exist? TMP_DIR
+  #end
+
+  #
+  #def test_optimizedframecell
+  #    # キチンと証明はしていないが、内部座標を直交座標として扱っても線形変換だから大丈夫だと思う。
+  #    log_file = "optimizeframecell.log"
+  #    FileUtils.rm log_file if File.exist? log_file
+
+  #    result = YAML.load(`bin/optimizeframecell #{TMP_MODEL_YAML} #{TMP_POSCAR}`)
+  #    # ハッシュの鍵がサイト名、値は元素名と座標からなる配列。
+  #    assert_equal(["frame_atoms", "interstitials"], result.keys)
+  #    assert_equal(
+  #        ["FS_000", "FS_001", "FS_003", "FS_020", "FS_060", "FS_300", "FS_900"],
+  #        result["frame_atoms"].keys
+  #    )
+  #    assert_equal(0, result["frame_atoms"]["FS_000"][0])
+  #    assert_equal(0, result["frame_atoms"]["FS_001"][0])
+  #    assert_equal(0, result["frame_atoms"]["FS_003"][0])
+  #    assert_equal(0, result["frame_atoms"]["FS_020"][0])
+  #    assert_equal(0, result["frame_atoms"]["FS_060"][0])
+  #    assert_equal(0, result["frame_atoms"]["FS_300"][0])
+  #    assert_equal(0, result["frame_atoms"]["FS_900"][0])
+
+  #    assert_in_delta(0.00, result["frame_atoms"]["FS_000"][1][0], $tolerance)
+  #    assert_in_delta(0.00, result["frame_atoms"]["FS_000"][1][1], $tolerance)
+  #    assert_in_delta(0.00, result["frame_atoms"]["FS_000"][1][2], $tolerance)
+  #    #あとは横着
+  #    #assert_equal([ 0.10, 0.10, 0.11 ], result["frame_atoms"]["FS_001"][1])
+  #    #assert_equal([ 0.10, 0.10, 0.13 ], result["frame_atoms"]["FS_003"][1])
+  #    #assert_equal([ 0.10, 0.12, 0.10 ], result["frame_atoms"]["FS_020"][1])
+  #    #assert_equal([ 0.10, 0.16, 0.10 ], result["frame_atoms"]["FS_060"][1])
+  #    #assert_equal([ 0.13, 0.10, 0.10 ], result["frame_atoms"]["FS_300"][1])
+  #    #assert_equal([ 0.19, 0.10, 0.10 ], result["frame_atoms"]["FS_900"][1])
+  #    # },
+  #    # "interstitials" => [
+  #    #   [ 1, [0.11, 0.11, 0.11]],
+  #    #   [ 2, [0.00, 0.00, 0.00]],
+  #    #   [ 2, [0.90, 0.90, 0.90]],
+  #    # ]
+  #    #}
+  #    #assert_equal(correct, result)
+
+  #    FileUtils.rm log_file if File.exist? log_file
+  #end
+
+  #def test_identifyatomsites
+  #    optimized_ficell_yaml = "#{TMP_DIR}/optimized_ficell.yaml"
+  #    FileUtils.rm optimized_ficell_yaml if File.exist? optimized_ficell_yaml
+  #    log_file = "identifyatomsites.log"
+  #    FileUtils.rm log_file if File.exist? log_file
+
+  #    optimized_ficell = {
+  #        "frame_atoms"=>
+  #        { "FS_000"=>[0, [0.60, 0.60, 0.60]],
+  #            "FS_001"=>[0, [0.60, 0.60, 0.61]],
+  #            "FS_003"=>[0, [0.60, 0.60, 0.63]],
+  #            "FS_020"=>[0, [0.60, 0.62, 0.60]],
+  #            "FS_060"=>[0, [0.60, 0.66, 0.60]],
+  #            "FS_300"=>[0, [0.63, 0.60, 0.60]],
+  #            "FS_900"=>[0, [0.69, 0.60, 0.60]],
+  #        },
+  #        "interstitials"=> [
+  #            [1, [0.61, 0.61, 0.61]],
+  #            [2, [0.50, 0.50, 0.50]],
+  #            [2, [0.10, 0.10, 0.10]],
+  #        ]
+  #    }
+  #    File.open(optimized_ficell_yaml, "w") do |io|
+  #        YAML.dump(optimized_ficell, io)
+  #    end
+  #    result = YAML.load(`bin/identifyatomsites #{TMP_MODEL_YAML} #{optimized_ficell_yaml}`)
+  #    correct = {
+  #        0 => [ "FS_000", "FS_001", "FS_003", "FS_020", "FS_060", "FS_300", "FS_900", ],
+  #        1 => [ "Te_000", ],
+  #        2 => [ "Oc_000", "Te_001", ]
+  #    }
+  #    assert_equal(correct, result)
+
+  #    FileUtils.rm optimized_ficell_yaml if File.exist? optimized_ficell_yaml
+  #    FileUtils.rm log_file if File.exist? log_file
+  #end
+
+  #def test_site2pov
+  #    results = `site2pov #{TMP_MODEL_YAML} Te_000`.split("\n")
+  #    corrects = [
+  #        "polygon { 4, < 0.0000,    0.0000,  0.0000>, < 0.0000,  0.0000,    1.0000>, < 0.0000,  1.0000,  0.0000>, < 0.0000,  0.0000,    0.0000> pigment { color rgb <1, 0, 0> } }",
+  #        "polygon { 4, < 0.0000,    0.0000,  1.0000>, < 0.0000,  1.0000,    0.0000>, < 1.0000,  0.0000,  0.0000>, < 0.0000,  0.0000,    1.0000> pigment { color rgb <1, 0, 0> } }",
+  #        "polygon { 4, < 0.0000,    1.0000,  0.0000>, < 1.0000,  0.0000,    0.0000>, < 0.0000,  0.0000,  0.0000>, < 0.0000,  1.0000,    0.0000> pigment { color rgb <1, 0, 0> } }",
+  #        "polygon { 4, < 1.0000,    0.0000,  0.0000>, < 0.0000,  0.0000,    0.0000>, < 0.0000,  0.0000,  1.0000>, < 1.0000,  0.0000,    0.0000> pigment { color rgb <1, 0, 0> } }",
+  #    ]
+  #    corrects.each_with_index do |line, index|
+  #        assert_equal(line, results[index])
+  #    end
+  #end
+
+  #def test_minExpConfiguration
+  #    config = {
+  #        0=>["FS_000", "FS_006"],
+  #        1=>["Te_002", "Te_006"]
+  #    }
+  #    config_yaml = "tmp_site_config.yaml"
+  #    File.open(config_yaml, "w") { |io| YAML.dump(config, io) }
+
+  #    operations = [
+  #        {
+  #            "FS_000" => "FS_000",
+  #            "FS_006" => "FS_006",
+  #            "Te_002" => "Te_002",
+  #            "Te_006" => "Te_006",
+  #            "Oc_000" => "Oc_000",
+  #        }, {
+  #            "FS_000" => "A0",
+  #            "FS_006" => "A1",
+  #            "Te_002" => "A2",
+  #            "Te_006" => "A3",
+  #            "Oc_000" => "A4",
+  #        }
+  #    ]
+  #    operations_yaml = "tmp_site_operations.yaml"
+  #    File.open(operations_yaml, "w") { |io| YAML.dump(operations, io) }
+
+  #    result = YAML.load(`bin/minExpConfiguration #{config_yaml} #{operations_yaml}`)
+  #    correct = {
+  #        0=>["A0", "A1"],
+  #        1=>["A2", "A3"]
+  #    }
+  #    assert_equal(correct, result)
+
+  #    FileUtils.rm operations_yaml if File.exist? operations_yaml
+  #    FileUtils.rm config_yaml if File.exist? config_yaml
+  #end
+
+  #def test_siteoperations
+  #    model = {
+  #        "frame_elements" => [ 0 ],
+  #        "frame_sites" => {
+  #            "FS_000"=>[0.00, 0.00, 0.00],
+  #        },
+  #        "symmetry_operations" => [
+  #            {
+  #                "rotation" => [[    1,  0,  0], [  0,  1,  0], [    0,  0,  1]],
+  #                "translation" => [  0.0000000,  0.0000000,  0.0000000]
+  #            }, {
+  #                "rotation" => [ [ -1,  0,  0], [    0, -1,  0], [  0,  0, -1]],
+  #                "translation" => [  0.0000000,  0.0000000,  0.0000000]
+  #            }
+  #        ],
+  #        "octahedral_sites" => {
+  #            "Oc_000"=> [
+  #                [["FS_000", [0, 0, 1]], ["FS_000", [1, 1, 0]]],
+  #                [["FS_000", [0, 1, 0]], ["FS_000", [1, 0, 1]]],
+  #                [["FS_000", [1, 0, 0]], ["FS_000", [0, 1, 1]]]
+  #            ]
+  #        },
+  #        "tetrahedral_sites" => {
+  #            "Te_000"=> [
+  #                ["FS_000", [0, 0, 0]], ["FS_000", [0, 0, 1]],
+  #                ["FS_000", [0, 1, 0]], ["FS_000", [1, 0, 0]]
+  #            ],
+  #            "Te_001"=> [
+  #                ["FS_000", [1, 1, 1]], ["FS_000", [1, 1, 0]],
+  #                ["FS_000", [1, 0, 1]], ["FS_000", [0, 1, 1]]
+  #            ]
+  #        }
+  #    }
+  #    File.open(TMP_MODEL_YAML, "w") do |io|
+  #        YAML.dump(model, io)
+  #    end
+  #    result = YAML.load(`bin/siteoperations #{TMP_MODEL_YAML}`)
+  #    correct = [
+  #        {
+  #            "FS_000" => "FS_000",
+  #            "Te_000" => "Te_000",
+  #            "Te_001" => "Te_001",
+  #            "Oc_000" => "Oc_000",
+  #        }, {
+  #            "FS_000" => "FS_000",
+  #            "Te_000" => "Te_000",
+  #            "Te_000" => "Te_001",
+  #            "Te_001" => "Te_000",
+  #            "Oc_000" => "Oc_000",
+  #        }
+  #    ]
+  #    assert_equal(correct, result)
+  #end
+
+  #def test_site2poscar
+  #    # ここのテストは Poscar クラスを VASP 5 形式に対応する改造してから。
+  #    lattice_yaml = "#{TMP_DIR}/lattice.yaml"
+  #    lattice = [10.0, 11.0, 12.0, 90.0, 91.0, 92.0]
+  #    File.open(lattice_yaml, "w") do |io|
+  #        YAML.dump(lattice, io)
+  #    end
+
+  #    site_configuration_yaml = "#{TMP_DIR}/site_configuration.yaml"
+  #    site_configuration = {
+  #        0 => [ "FS_000", "FS_001"],
+  #        1 => [ "Oc_000", "Te_000"],
+  #    }
+  #    File.open(site_configuration_yaml, "w") do |io|
+  #        YAML.dump(site_configuration, io)
+  #    end
+
+  #    FileUtils.rm lattice_yaml if File.exist? lattice_yaml
+  #    FileUtils.rm site_configuration_yaml if File.exist? site_configuration_yaml
+  #end
+
+  #def test_genuniqsites
+  #    # setting up
+  #    files = [ "00-0000.yaml", "01-0000.yaml", "01-0001.yaml" ]
+  #    files.each { |file| FileUtils.rm file if FileTest.exist? file }
+  #    command =
+  #        "bin/genuniqsites " +
+  #        "test/uniquesitesgenerator/elements-sitenames.yaml " +
+  #        "test/uniquesitesgenerator/siteoperations.yaml " +
+  #        "-l 1"
+  #    system("#{command}")
+  #    assert_equal( {0 => []}, YAML.load_file("00-0000.yaml"))
+  #    #
+  #    assert_equal( {0 => ["a"]}, YAML.load_file("01-0000.yaml"))
+  #    assert_equal( {0 => ["c"]}, YAML.load_file("01-0001.yaml"))
+  #    #
+  #    files = [ "00-0000.yaml", "01-0000.yaml", "01-0001.yaml" ]
+  #    files.each { |file| FileUtils.rm file if FileTest.exist? file }
+  #end
+
+end
+

data/test/test_crystana.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestCrysna < Test::Unit::TestCase
+  #def test_something_for_real
+  #    flunk "hey buddy, you should probably rename this file and start testing for real"
+  #end
+end

data/test/test_frameatom.rb

@@ -0,0 +1,22 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "crysna/frameatom.rb"
+
+# assert_equal( cor, data)
+# assert_in_delta( cor, data, $tolerance )
+# assert_raise( RuntimeError ){}
+
+class TC_FrameAtom < Test::Unit::TestCase
+  def setup
+    @fa00 = FrameAtom.new(0, [0.0, 0.0, 0.0])
+  end
+  
+  def test_is_a?
+    assert_equal(true, @fa00.is_a?(CrystalCell::Atom))
+  end
+
+end
+

data/test/test_frameinterstitialcell.rb

@@ -0,0 +1,939 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "crysna/frameinterstitialcell.rb"
+require "stringio"
+
+$test = true
+
+class FrameInterstitialCell
+  #public :site_name
+  #public :include_in_27_polyhedra?
+  public :equivalent_cells
+  public :frame_atoms
+  public :interstitial_atoms
+  public :frame_cell
+  public :interstitial_cell
+end
+
+class TC_FrameInterstitialCell < Test::Unit::TestCase
+  $tolerance = 10.0 ** (-10)
+
+  def setup
+    @frame_sites ={
+      "FS_000" => Mageo::Vector3DInternal[0.10, 0.10, 0.10],
+      "FS_001" => Mageo::Vector3DInternal[0.10, 0.10, 0.11],
+      "FS_002" => Mageo::Vector3DInternal[0.10, 0.10, 0.13],
+      "FS_010" => Mageo::Vector3DInternal[0.10, 0.12, 0.10],
+      "FS_020" => Mageo::Vector3DInternal[0.10, 0.16, 0.10],
+      "FS_100" => Mageo::Vector3DInternal[0.13, 0.10, 0.10],
+      "FS_200" => Mageo::Vector3DInternal[0.19, 0.10, 0.10],
+    }
+
+    @lattice_axes = CrystalCell::LatticeAxes.new([[1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]])
+    atoms = [
+      FrameAtom.new(           0, [0.10, 0.10, 0.10]),
+      FrameAtom.new(           0, [0.10, 0.10, 0.11]),
+      FrameAtom.new(           0, [0.10, 0.10, 0.13]),
+      FrameAtom.new(           0, [0.10, 0.12, 0.10]),
+      FrameAtom.new(           0, [0.10, 0.16, 0.10]),
+      FrameAtom.new(           0, [0.13, 0.10, 0.10]),
+      FrameAtom.new(           0, [0.19, 0.10, 0.10]),
+      InterstitialAtom.new(1, [0.50, 0.50, 0.30]),
+    ]
+    @fic00 = FrameInterstitialCell.new(@lattice_axes, atoms)
+
+    atoms = [
+      FrameAtom.new(           0, [0.00, 0.00, 0.00]),
+      InterstitialAtom.new(0, [0.50, 0.50, 0.50]),
+      InterstitialAtom.new(1, [0.10, 0.10, 0.10]),
+      InterstitialAtom.new(2, [0.90, 0.90, 0.90]),
+      InterstitialAtom.new(3, [0.01, 0.01, 0.01]),
+      InterstitialAtom.new(3, [0.90, 0.01, 0.01]),
+      InterstitialAtom.new(3, [0.01, 0.90, 0.01]),
+      InterstitialAtom.new(3, [0.01, 0.01, 0.90]),
+      InterstitialAtom.new(4, [0.99, 0.99, 0.99]),
+      InterstitialAtom.new(4, [0.10, 0.99, 0.99]),
+      InterstitialAtom.new(4, [0.99, 0.10, 0.99]),
+      InterstitialAtom.new(4, [0.99, 0.99, 0.10]),
+      InterstitialAtom.new(5, [0.99, 0.10, 0.10]),
+      InterstitialAtom.new(5, [0.10, 0.99, 0.10]),
+      InterstitialAtom.new(5, [0.10, 0.10, 0.99]),
+      InterstitialAtom.new(5, [0.01, 0.90, 0.90]),
+      InterstitialAtom.new(5, [0.90, 0.01, 0.90]),
+      InterstitialAtom.new(5, [0.90, 0.90, 0.01]),
+    ]
+    @fic01 = FrameInterstitialCell.new(@lattice_axes, atoms)
+
+    atoms = [
+      FrameAtom.new(           0, [0.00, 0.00, 0.00]),
+      InterstitialAtom.new(1, [0.60, 0.60, 0.60]),
+      InterstitialAtom.new(2, [0.40, 0.40, 0.40]),
+      InterstitialAtom.new(3, [0.51, 0.51, 0.51]),
+      InterstitialAtom.new(3, [0.40, 0.51, 0.51]),
+      InterstitialAtom.new(3, [0.51, 0.40, 0.51]),
+      InterstitialAtom.new(3, [0.51, 0.51, 0.40]),
+      InterstitialAtom.new(4, [0.49, 0.49, 0.49]),
+      InterstitialAtom.new(4, [0.60, 0.49, 0.49]),
+      InterstitialAtom.new(4, [0.49, 0.60, 0.49]),
+      InterstitialAtom.new(4, [0.49, 0.49, 0.60]),
+      InterstitialAtom.new(5, [0.49, 0.60, 0.60]),
+      InterstitialAtom.new(5, [0.60, 0.49, 0.60]),
+      InterstitialAtom.new(5, [0.60, 0.60, 0.49]),
+      InterstitialAtom.new(5, [0.51, 0.40, 0.40]),
+      InterstitialAtom.new(5, [0.40, 0.51, 0.40]),
+      InterstitialAtom.new(5, [0.40, 0.40, 0.51]),
+    ]
+    @fic02 = FrameInterstitialCell.new(@lattice_axes, atoms)
+
+    lattice_axes = [[10.0, 0.0, 0.0], [0.0, 20.0, 0.0], [0.0, 0.0, 30.0]]
+    @fic03 = FrameInterstitialCell.new(lattice_axes)
+
+    @la = CrystalCell::LatticeAxes.new( [ [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] ] )
+
+    @oc_sites00 = {
+      "Oc_00"=> [
+        [["FS_00", [1, 0, 0]], ["FS_00", [0, 1, 1]]],
+        [["FS_00", [0, 1, 0]], ["FS_00", [1, 0, 1]]],
+        [["FS_00", [0, 0, 1]], ["FS_00", [1, 1, 0]]]
+      ]
+    }
+
+    @te_sites00 = {
+      "Te_00"=> [
+        ["FS_00", [0, 0, 0]],
+        ["FS_00", [1, 0, 0]],
+        ["FS_00", [0, 1, 0]],
+        ["FS_00", [0, 0, 1]]
+      ],
+      "Te_01"=> [
+        ["FS_00", [1, 1, 1]],
+        ["FS_00", [0, 1, 1]],
+        ["FS_00", [1, 0, 1]],
+        ["FS_00", [1, 1, 0]]
+      ]
+    }
+  end
+
+  def test_initialize
+    vectors00 = [[1.02, 0.02, 0.02], [0.0, 1.01, 0.01], [0.0, 0.0, 1.00]]
+    atoms = [
+      CrystalCell::Atom.new(0, [0.0, 0.0, 0.0])
+    ]
+    assert_raise(FrameInterstitialCell::TypeError){
+      FrameInterstitialCell.new(vectors00, atoms )
+    }
+
+    assert_nothing_raised{
+      FrameInterstitialCell.new(
+        [[1.02, 0.02, 0.02], [0.0, 1.01, 0.01], [0.0, 0.0, 1.00]]
+      )
+    }
+
+    atoms = [ FrameAtom.new(0, [0.0, 0.0, 0.0]) ]
+    assert_nothing_raised{
+      FrameInterstitialCell.new(
+        [[1.02, 0.02, 0.02], [0.0, 1.01, 0.01], [0.0, 0.0, 1.00]]
+      )
+    }
+
+    atoms = [ InterstitialAtom.new(0, [0.0, 0.0, 0.0]) ]
+    assert_nothing_raised{
+      FrameInterstitialCell.new(
+        [[1.02, 0.02, 0.02], [0.0, 1.01, 0.01], [0.0, 0.0, 1.00]]
+      )
+    }
+
+  end
+
+  def test_optimized_cell
+    io = StringIO.new
+    frame_sites ={
+      "FS_000" => Mageo::Vector3DInternal[0.00, 0.00, 0.00],
+      "FS_001" => Mageo::Vector3DInternal[0.00, 0.00, 0.01],
+      "FS_002" => Mageo::Vector3DInternal[0.00, 0.00, 0.03],
+      "FS_010" => Mageo::Vector3DInternal[0.00, 0.02, 0.00],
+      "FS_020" => Mageo::Vector3DInternal[0.00, 0.06, 0.00],
+      "FS_100" => Mageo::Vector3DInternal[0.03, 0.00, 0.00],
+      "FS_200" => Mageo::Vector3DInternal[0.09, 0.00, 0.00],
+    }
+
+    @lattice_axes = CrystalCell::LatticeAxes.new([[1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]])
+    atoms = [
+      FrameAtom.new(           0, [0.000, 0.000, 0.000]),
+      FrameAtom.new(           0, [0.000, 0.000, 0.010]),
+      FrameAtom.new(           0, [0.000, 0.000, 0.037]),
+      FrameAtom.new(           0, [0.000, 0.020, 0.000]),
+      FrameAtom.new(           0, [0.000, 0.067, 0.000]),
+      FrameAtom.new(           0, [0.030, 0.000, 0.000]),
+      FrameAtom.new(           0, [0.097, 0.000, 0.000]),
+    ]
+    fic10 = FrameInterstitialCell.new(@lattice_axes, atoms)
+    t = fic10.optimized_cell(frame_sites, io)
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(CrystalCell::LatticeAxes, t.axes.class)
+    assert_in_delta(1.0, t.axes[0][0], $tolerance)
+    assert_in_delta(1.0, t.axes[0][1], $tolerance)
+    assert_in_delta(1.0, t.axes[0][2], $tolerance)
+    assert_in_delta(0.0, t.axes[1][0], $tolerance)
+    assert_in_delta(1.0, t.axes[1][1], $tolerance)
+    assert_in_delta(1.0, t.axes[1][2], $tolerance)
+    assert_in_delta(0.0, t.axes[2][0], $tolerance)
+    assert_in_delta(0.0, t.axes[2][1], $tolerance)
+    assert_in_delta(1.0, t.axes[2][2], $tolerance)
+    assert_equal(7, t.atoms.size)
+
+    assert_equal(Mageo::Vector3DInternal, t.atoms[0].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[1].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[2].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[3].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[4].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[5].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[6].position.class)
+    assert_in_delta(-0.001, t.atoms[0].position[0], $tolerance)
+    assert_in_delta(-0.001, t.atoms[0].position[1], $tolerance)
+    assert_in_delta(-0.001, t.atoms[0].position[2], $tolerance)
+    assert_in_delta(-0.001, t.atoms[1].position[0], $tolerance)
+    assert_in_delta(-0.001, t.atoms[1].position[1], $tolerance)
+    assert_in_delta( 0.009, t.atoms[1].position[2], $tolerance)
+    assert_in_delta(-0.001, t.atoms[2].position[0], $tolerance)
+    assert_in_delta(-0.001, t.atoms[2].position[1], $tolerance)
+    assert_in_delta( 0.036, t.atoms[2].position[2], $tolerance)
+    assert_in_delta(-0.001, t.atoms[3].position[0], $tolerance)
+    assert_in_delta( 0.019, t.atoms[3].position[1], $tolerance)
+    assert_in_delta(-0.001, t.atoms[3].position[2], $tolerance)
+    assert_in_delta(-0.001, t.atoms[4].position[0], $tolerance)
+    assert_in_delta( 0.066, t.atoms[4].position[1], $tolerance)
+    assert_in_delta(-0.001, t.atoms[4].position[2], $tolerance)
+    assert_in_delta( 0.029, t.atoms[5].position[0], $tolerance)
+    assert_in_delta(-0.001, t.atoms[5].position[1], $tolerance)
+    assert_in_delta(-0.001, t.atoms[5].position[2], $tolerance)
+    assert_in_delta( 0.096, t.atoms[6].position[0], $tolerance)
+    assert_in_delta(-0.001, t.atoms[6].position[1], $tolerance)
+    assert_in_delta(-0.001, t.atoms[6].position[2], $tolerance)
+
+    assert_equal("FS_000", t.atoms[0].name)
+    assert_equal("FS_001", t.atoms[1].name)
+    assert_equal("FS_002", t.atoms[2].name)
+    assert_equal("FS_010", t.atoms[3].name)
+    assert_equal("FS_020", t.atoms[4].name)
+    assert_equal("FS_100", t.atoms[5].name)
+    assert_equal("FS_200", t.atoms[6].name)
+    assert_equal( "Equivalent cell No.00: Original.; Rough translation: ( 0.00000,  0.00000,  0.00000), 0th atom of frame to FS_000; Precise translation: (-0.00100, -0.00100, -0.00100)\n", t.comment)
+
+    io = StringIO.new
+
+    # そのまま重なるもの。
+    t = @fic00.optimized_cell(@frame_sites, io)
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(CrystalCell::LatticeAxes, t.axes.class)
+    assert_in_delta(1.0, t.axes[0][0], $tolerance)
+    assert_in_delta(1.0, t.axes[0][1], $tolerance)
+    assert_in_delta(1.0, t.axes[0][2], $tolerance)
+    assert_in_delta(0.0, t.axes[1][0], $tolerance)
+    assert_in_delta(1.0, t.axes[1][1], $tolerance)
+    assert_in_delta(1.0, t.axes[1][2], $tolerance)
+    assert_in_delta(0.0, t.axes[2][0], $tolerance)
+    assert_in_delta(0.0, t.axes[2][1], $tolerance)
+    assert_in_delta(1.0, t.axes[2][2], $tolerance)
+    assert_equal(8, t.atoms.size)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.10], t.atoms[0].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.11], t.atoms[1].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.13], t.atoms[2].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.12, 0.10], t.atoms[3].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.16, 0.10], t.atoms[4].position)
+    assert_equal(Mageo::Vector3DInternal[0.13, 0.10, 0.10], t.atoms[5].position)
+    assert_equal(Mageo::Vector3DInternal[0.19, 0.10, 0.10], t.atoms[6].position)
+    assert_equal(Mageo::Vector3DInternal[0.50, 0.50, 0.30], t.atoms[7].position)
+    assert_equal("FS_000", t.atoms[0].name)
+    assert_equal("FS_001", t.atoms[1].name)
+    assert_equal("FS_002", t.atoms[2].name)
+    assert_equal("FS_010", t.atoms[3].name)
+    assert_equal("FS_020", t.atoms[4].name)
+    assert_equal("FS_100", t.atoms[5].name)
+    assert_equal("FS_200", t.atoms[6].name)
+    assert_equal( "Equivalent cell No.00: Original.; Rough translation: ( 0.00000,  0.00000,  0.00000), 0th atom of frame to FS_000; Precise translation: ( 0.00000,  0.00000,  0.00000)\n", t.comment)
+
+    # 並進移動を加えたもの。
+    cell = @fic00.translate(Mageo::Vector3DInternal[0.1, 0.2, 0.3])
+    assert_equal(Mageo::Vector3DInternal, cell.atoms[0].position.class)
+    assert_in_delta(0.20, cell.atoms[0].position[0], $tolerance)
+    assert_in_delta(0.30, cell.atoms[0].position[1], $tolerance)
+    assert_in_delta(0.40, cell.atoms[0].position[2], $tolerance)
+    #
+    t = cell.optimized_cell(@frame_sites, io)
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(8, t.atoms.size)
+    assert_in_delta(0.10, t.atoms[0].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[0].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[0].position[2], $tolerance)
+    assert_in_delta(0.10, t.atoms[1].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[1].position[1], $tolerance)
+    assert_in_delta(0.11, t.atoms[1].position[2], $tolerance)
+    assert_in_delta(0.10, t.atoms[2].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[2].position[1], $tolerance)
+    assert_in_delta(0.13, t.atoms[2].position[2], $tolerance)
+    assert_in_delta(0.10, t.atoms[3].position[0], $tolerance)
+    assert_in_delta(0.12, t.atoms[3].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[3].position[2], $tolerance)
+    assert_in_delta(0.10, t.atoms[4].position[0], $tolerance)
+    assert_in_delta(0.16, t.atoms[4].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[4].position[2], $tolerance)
+    assert_in_delta(0.13, t.atoms[5].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[5].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[5].position[2], $tolerance)
+    assert_in_delta(0.19, t.atoms[6].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[6].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[6].position[2], $tolerance)
+    assert_in_delta(0.50, t.atoms[7].position[0], $tolerance)
+    assert_in_delta(0.50, t.atoms[7].position[1], $tolerance)
+    assert_in_delta(0.30, t.atoms[7].position[2], $tolerance)
+    assert_equal("FS_000", t.atoms[0].name)
+    assert_equal("FS_001", t.atoms[1].name)
+    assert_equal("FS_002", t.atoms[2].name)
+    assert_equal("FS_010", t.atoms[3].name)
+    assert_equal("FS_020", t.atoms[4].name)
+    assert_equal("FS_100", t.atoms[5].name)
+    assert_equal("FS_200", t.atoms[6].name)
+    assert_equal("Equivalent cell No.00: Original.; Rough translation: (-0.10000, -0.20000, -0.30000), 0th atom of frame to FS_000; Precise translation: ( 0.00000,  0.00000,  0.00000)\n", t.comment)
+    
+
+    # 周期境界をまたぐもの。
+    cell = @fic00.translate(Mageo::Vector3DInternal[0.85, 0.85, 0.85])
+    cell.to_pcell.to_cell
+    assert_equal(Mageo::Vector3DInternal, cell.atoms[0].position.class)
+    assert_in_delta(0.95, cell.atoms[0].position[0], $tolerance)
+    assert_in_delta(0.95, cell.atoms[0].position[1], $tolerance)
+    assert_in_delta(0.95, cell.atoms[0].position[2], $tolerance)
+    assert_equal(Mageo::Vector3DInternal, cell.atoms[6].position.class)
+    assert_in_delta(1.04, cell.atoms[6].position[0], $tolerance)
+    assert_in_delta(0.95, cell.atoms[6].position[1], $tolerance)
+    assert_in_delta(0.95, cell.atoms[6].position[2], $tolerance)
+    #
+    t = cell.optimized_cell(@frame_sites, io)
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(8, t.atoms.size)
+    assert_in_delta(0.10, t.atoms[0].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[0].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[0].position[2], $tolerance)
+    assert_in_delta(0.10, t.atoms[1].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[1].position[1], $tolerance)
+    assert_in_delta(0.11, t.atoms[1].position[2], $tolerance)
+    assert_in_delta(0.10, t.atoms[2].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[2].position[1], $tolerance)
+    assert_in_delta(0.13, t.atoms[2].position[2], $tolerance)
+    assert_in_delta(0.10, t.atoms[3].position[0], $tolerance)
+    assert_in_delta(0.12, t.atoms[3].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[3].position[2], $tolerance)
+    assert_in_delta(0.10, t.atoms[4].position[0], $tolerance)
+    assert_in_delta(0.16, t.atoms[4].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[4].position[2], $tolerance)
+    assert_in_delta(0.13, t.atoms[5].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[5].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[5].position[2], $tolerance)
+    assert_in_delta(0.19, t.atoms[6].position[0], $tolerance)
+    assert_in_delta(0.10, t.atoms[6].position[1], $tolerance)
+    assert_in_delta(0.10, t.atoms[6].position[2], $tolerance)
+    assert_in_delta(0.50, t.atoms[7].position[0], $tolerance)
+    assert_in_delta(0.50, t.atoms[7].position[1], $tolerance)
+    assert_in_delta(0.30, t.atoms[7].position[2], $tolerance)
+    assert_equal("FS_000", t.atoms[0].name)
+    assert_equal("FS_001", t.atoms[1].name)
+    assert_equal("FS_002", t.atoms[2].name)
+    assert_equal("FS_010", t.atoms[3].name)
+    assert_equal("FS_020", t.atoms[4].name)
+    assert_equal("FS_100", t.atoms[5].name)
+    assert_equal("FS_200", t.atoms[6].name)
+    assert_equal("Equivalent cell No.00: Original.; Rough translation: (-0.85000, -0.85000, -0.85000), 0th atom of frame to FS_000; Precise translation: ( 0.00000,  0.00000,  0.00000)\n", t.comment)
+
+    # a軸反転したもの。
+    cell = @fic00.inverse_axis(0)
+    assert_equal(Mageo::Vector3DInternal[-0.10, 0.10, 0.10], cell.atoms[0].position)
+    #
+    t = cell.optimized_cell(@frame_sites, io)
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(8, t.atoms.size)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.10], t.atoms[0].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.11], t.atoms[1].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.13], t.atoms[2].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.12, 0.10], t.atoms[3].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.16, 0.10], t.atoms[4].position)
+    assert_equal(Mageo::Vector3DInternal[0.13, 0.10, 0.10], t.atoms[5].position)
+    assert_equal(Mageo::Vector3DInternal[0.19, 0.10, 0.10], t.atoms[6].position)
+    assert_equal(Mageo::Vector3DInternal[0.50, 0.50, 0.30], t.atoms[7].position)
+    assert_equal("FS_000", t.atoms[0].name)
+    assert_equal("FS_001", t.atoms[1].name)
+    assert_equal("FS_002", t.atoms[2].name)
+    assert_equal("FS_010", t.atoms[3].name)
+    assert_equal("FS_020", t.atoms[4].name)
+    assert_equal("FS_100", t.atoms[5].name)
+    assert_equal("FS_200", t.atoms[6].name)
+    assert_equal("Equivalent cell No.06: Original -> Axis 'a' inversed.; Rough translation: ( 0.00000,  0.00000,  0.00000), 0th atom of frame to FS_000; Precise translation: ( 0.00000,  0.00000,  0.00000)\n", t.comment)
+
+
+    # a,b軸交換したもの。
+    cell = @fic00.exchange_axes([0,1])
+    assert_equal(Mageo::Vector3DInternal[0.12, 0.10, 0.10], cell.atoms[3].position)
+    #
+    t = cell.optimized_cell(@frame_sites, io)
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(8, t.atoms.size)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.10], t.atoms[0].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.11], t.atoms[1].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.10, 0.13], t.atoms[2].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.12, 0.10], t.atoms[3].position)
+    assert_equal(Mageo::Vector3DInternal[0.10, 0.16, 0.10], t.atoms[4].position)
+    assert_equal(Mageo::Vector3DInternal[0.13, 0.10, 0.10], t.atoms[5].position)
+    assert_equal(Mageo::Vector3DInternal[0.19, 0.10, 0.10], t.atoms[6].position)
+    assert_equal(Mageo::Vector3DInternal[0.50, 0.50, 0.30], t.atoms[7].position)
+    assert_equal("FS_000", t.atoms[0].name)
+    assert_equal("FS_001", t.atoms[1].name)
+    assert_equal("FS_002", t.atoms[2].name)
+    assert_equal("FS_010", t.atoms[3].name)
+    assert_equal("FS_020", t.atoms[4].name)
+    assert_equal("FS_100", t.atoms[5].name)
+    assert_equal("FS_200", t.atoms[6].name)
+    assert_equal("Equivalent cell No.03: Original -> Axes exchanged(a,b,c -> b,a,c).; Rough translation: ( 0.00000,  0.00000,  0.00000), 0th atom of frame to FS_000; Precise translation: ( 0.00000,  0.00000,  0.00000)\n", t.comment)
+
+    # 変位をまぜたもの。
+    lattice_axes = [[1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]]
+    atoms = [
+      FrameAtom.new(           0, [0.1007, 0.1007, 0.1007]),
+      FrameAtom.new(           0, [0.1000, 0.1000, 0.1100]),
+      FrameAtom.new(           0, [0.1000, 0.1000, 0.1300]),
+      FrameAtom.new(           0, [0.1000, 0.1200, 0.1000]),
+      FrameAtom.new(           0, [0.1000, 0.1600, 0.1000]),
+      FrameAtom.new(           0, [0.1300, 0.1000, 0.1000]),
+      FrameAtom.new(           0, [0.1900, 0.1000, 0.1000]),
+      InterstitialAtom.new(1, [0.5000, 0.5000, 0.3000]),
+    ]
+    cell = FrameInterstitialCell.new(lattice_axes, atoms)
+    assert_equal(Mageo::Vector3DInternal[0.1007, 0.1007, 0.1007], cell.atoms[0].position)
+    #
+    t = cell.optimized_cell(@frame_sites, io)
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(
+      CrystalCell::LatticeAxes.new([[1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]]),
+      t.axes
+    )
+    assert_equal(8, t.atoms.size)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[0].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[1].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[2].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[3].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[4].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[5].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[6].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[7].position.class)
+    assert_in_delta(0.1006, t.atoms[0].position[0], $tolerance)
+    assert_in_delta(0.0999, t.atoms[1].position[0], $tolerance)
+    assert_in_delta(0.0999, t.atoms[2].position[0], $tolerance)
+    assert_in_delta(0.0999, t.atoms[3].position[0], $tolerance)
+    assert_in_delta(0.0999, t.atoms[4].position[0], $tolerance)
+    assert_in_delta(0.1299, t.atoms[5].position[0], $tolerance)
+    assert_in_delta(0.1899, t.atoms[6].position[0], $tolerance)
+    assert_in_delta(0.4999, t.atoms[7].position[0], $tolerance)
+    assert_in_delta(0.1006, t.atoms[0].position[1], $tolerance)
+    assert_in_delta(0.0999, t.atoms[1].position[1], $tolerance)
+    assert_in_delta(0.0999, t.atoms[2].position[1], $tolerance)
+    assert_in_delta(0.1199, t.atoms[3].position[1], $tolerance)
+    assert_in_delta(0.1599, t.atoms[4].position[1], $tolerance)
+    assert_in_delta(0.0999, t.atoms[5].position[1], $tolerance)
+    assert_in_delta(0.0999, t.atoms[6].position[1], $tolerance)
+    assert_in_delta(0.4999, t.atoms[7].position[1], $tolerance)
+    assert_in_delta(0.1006, t.atoms[0].position[2], $tolerance)
+    assert_in_delta(0.1099, t.atoms[1].position[2], $tolerance)
+    assert_in_delta(0.1299, t.atoms[2].position[2], $tolerance)
+    assert_in_delta(0.0999, t.atoms[3].position[2], $tolerance)
+    assert_in_delta(0.0999, t.atoms[4].position[2], $tolerance)
+    assert_in_delta(0.0999, t.atoms[5].position[2], $tolerance)
+    assert_in_delta(0.0999, t.atoms[6].position[2], $tolerance)
+    assert_in_delta(0.2999, t.atoms[7].position[2], $tolerance)
+    assert_equal("FS_000", t.atoms[0].name)
+    assert_equal("FS_001", t.atoms[1].name)
+    assert_equal("FS_002", t.atoms[2].name)
+    assert_equal("FS_010", t.atoms[3].name)
+    assert_equal("FS_020", t.atoms[4].name)
+    assert_equal("FS_100", t.atoms[5].name)
+    assert_equal("FS_200", t.atoms[6].name)
+    assert_equal("Equivalent cell No.00: Original.; Rough translation: (-0.00070, -0.00070, -0.00070), 0th atom of frame to FS_000; Precise translation: ( 0.00060,  0.00060,  0.00060)\n", t.comment)
+
+    # 複合的なもの。
+    lattice_axes = [[1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]]
+    atoms = [
+      FrameAtom.new(           0, [0.1007, 0.1007, 0.1007]),
+      FrameAtom.new(           0, [0.1000, 0.1000, 0.1100]),
+      FrameAtom.new(           0, [0.1000, 0.1000, 0.1300]),
+      FrameAtom.new(           0, [0.1000, 0.1200, 0.1000]),
+      FrameAtom.new(           0, [0.1000, 0.1600, 0.1000]),
+      FrameAtom.new(           0, [0.1300, 0.1000, 0.1000]),
+      FrameAtom.new(           0, [0.1900, 0.1000, 0.1000]),
+      InterstitialAtom.new(1, [0.5000, 0.5000, 0.3000]),
+    ]
+    cell = FrameInterstitialCell.new(lattice_axes, atoms)
+    cell.translate!(Mageo::Vector3DInternal[0.85, 0.85, 0.85])
+    cell.inverse_axis!(0)
+    cell.exchange_axes!([0,1])
+    #
+    assert_equal(Mageo::Vector3DInternal, cell.atoms[6].position.class)
+    assert_in_delta( 0.9500, cell.atoms[6].position[0], $tolerance)
+    assert_in_delta(-1.0400, cell.atoms[6].position[1], $tolerance)
+    assert_in_delta( 0.9500, cell.atoms[6].position[2], $tolerance)
+    #
+    t = cell.optimized_cell(@frame_sites, io)
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(CrystalCell::LatticeAxes, t.axes.class)
+    assert_in_delta(1.0, t.axes[0][0], $tolerance)
+    assert_in_delta(1.0, t.axes[0][1], $tolerance)
+    assert_in_delta(1.0, t.axes[0][2], $tolerance)
+    assert_in_delta(0.0, t.axes[1][0], $tolerance)
+    assert_in_delta(1.0, t.axes[1][1], $tolerance)
+    assert_in_delta(1.0, t.axes[1][2], $tolerance)
+    assert_in_delta(0.0, t.axes[2][0], $tolerance)
+    assert_in_delta(0.0, t.axes[2][1], $tolerance)
+    assert_in_delta(1.0, t.axes[2][2], $tolerance)
+    assert_equal(8, t.atoms.size)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[0].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[1].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[2].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[3].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[4].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[5].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[6].position.class)
+    assert_equal(Mageo::Vector3DInternal, t.atoms[7].position.class)
+    assert_in_delta(0.1006, t.atoms[0].position[0], $tolerance)
+    assert_in_delta(0.0999, t.atoms[1].position[0], $tolerance)
+    assert_in_delta(0.0999, t.atoms[2].position[0], $tolerance)
+    assert_in_delta(0.0999, t.atoms[3].position[0], $tolerance)
+    assert_in_delta(0.0999, t.atoms[4].position[0], $tolerance)
+    assert_in_delta(0.1299, t.atoms[5].position[0], $tolerance)
+    assert_in_delta(0.1899, t.atoms[6].position[0], $tolerance)
+    assert_in_delta(0.4999, t.atoms[7].position[0], $tolerance)
+    assert_in_delta(0.1006, t.atoms[0].position[1], $tolerance)
+    assert_in_delta(0.0999, t.atoms[1].position[1], $tolerance)
+    assert_in_delta(0.0999, t.atoms[2].position[1], $tolerance)
+    assert_in_delta(0.1199, t.atoms[3].position[1], $tolerance)
+    assert_in_delta(0.1599, t.atoms[4].position[1], $tolerance)
+    assert_in_delta(0.0999, t.atoms[5].position[1], $tolerance)
+    assert_in_delta(0.0999, t.atoms[6].position[1], $tolerance)
+    assert_in_delta(0.4999, t.atoms[7].position[1], $tolerance)
+    assert_in_delta(0.1006, t.atoms[0].position[2], $tolerance)
+    assert_in_delta(0.1099, t.atoms[1].position[2], $tolerance)
+    assert_in_delta(0.1299, t.atoms[2].position[2], $tolerance)
+    assert_in_delta(0.0999, t.atoms[3].position[2], $tolerance)
+    assert_in_delta(0.0999, t.atoms[4].position[2], $tolerance)
+    assert_in_delta(0.0999, t.atoms[5].position[2], $tolerance)
+    assert_in_delta(0.0999, t.atoms[6].position[2], $tolerance)
+    assert_in_delta(0.2999, t.atoms[7].position[2], $tolerance)
+    assert_equal("FS_000", t.atoms[0].name)
+    assert_equal("FS_001", t.atoms[1].name)
+    assert_equal("FS_002", t.atoms[2].name)
+    assert_equal("FS_010", t.atoms[3].name)
+    assert_equal("FS_020", t.atoms[4].name)
+    assert_equal("FS_100", t.atoms[5].name)
+    assert_equal("FS_200", t.atoms[6].name)
+    assert_equal("Equivalent cell No.09: Original -> Axes exchanged(a,b,c -> b,a,c) -> Axis 'a' inversed.; Rough translation: (-0.85070, -0.85070, -0.85070), 0th atom of frame to FS_000; Precise translation: ( 0.00060,  0.00060,  0.00060)\n", t.comment)
+
+end
+
+  def test_frame_atoms
+    assert_equal(
+      [ 
+        FrameAtom.new(           0, [0.10, 0.10, 0.10]),
+        FrameAtom.new(           0, [0.10, 0.10, 0.11]),
+        FrameAtom.new(           0, [0.10, 0.10, 0.13]),
+        FrameAtom.new(           0, [0.10, 0.12, 0.10]),
+        FrameAtom.new(           0, [0.10, 0.16, 0.10]),
+        FrameAtom.new(           0, [0.13, 0.10, 0.10]),
+        FrameAtom.new(           0, [0.19, 0.10, 0.10]),
+      ],
+      @fic00.frame_atoms
+    )
+  end
+
+  def test_interstitial_atoms
+    assert_equal(
+      [
+        InterstitialAtom.new(1, [0.50, 0.50, 0.30]),
+      ],
+      @fic00.interstitial_atoms
+    )
+  end
+
+  def test_frame_cell
+    t = @fic00.frame_cell
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(CrystalCell::LatticeAxes, t.axes.class)
+    assert_in_delta(1.0, t.axes[0][0], $tolerance)
+    assert_in_delta(1.0, t.axes[0][1], $tolerance)
+    assert_in_delta(1.0, t.axes[0][2], $tolerance)
+    assert_in_delta(0.0, t.axes[1][0], $tolerance)
+    assert_in_delta(1.0, t.axes[1][1], $tolerance)
+    assert_in_delta(1.0, t.axes[1][2], $tolerance)
+    assert_in_delta(0.0, t.axes[2][0], $tolerance)
+    assert_in_delta(0.0, t.axes[2][1], $tolerance)
+    assert_in_delta(1.0, t.axes[2][2], $tolerance)
+    assert_equal(7, t.atoms.size)
+    assert_equal(FrameAtom.new(0, [0.10, 0.10, 0.10]), t.atoms[0])
+    assert_equal(FrameAtom.new(0, [0.10, 0.10, 0.11]), t.atoms[1])
+    assert_equal(FrameAtom.new(0, [0.10, 0.10, 0.13]), t.atoms[2])
+    assert_equal(FrameAtom.new(0, [0.10, 0.12, 0.10]), t.atoms[3])
+    assert_equal(FrameAtom.new(0, [0.10, 0.16, 0.10]), t.atoms[4])
+    assert_equal(FrameAtom.new(0, [0.13, 0.10, 0.10]), t.atoms[5])
+    assert_equal(FrameAtom.new(0, [0.19, 0.10, 0.10]), t.atoms[6])
+  end
+
+  def test_interstitial_cell
+    t = @fic00.interstitial_cell
+    assert_equal(FrameInterstitialCell, t.class)
+    assert_equal(CrystalCell::LatticeAxes, t.axes.class)
+    assert_in_delta(1.0, t.axes[0][0], $tolerance)
+    assert_in_delta(1.0, t.axes[0][1], $tolerance)
+    assert_in_delta(1.0, t.axes[0][2], $tolerance)
+    assert_in_delta(0.0, t.axes[1][0], $tolerance)
+    assert_in_delta(1.0, t.axes[1][1], $tolerance)
+    assert_in_delta(1.0, t.axes[1][2], $tolerance)
+    assert_in_delta(0.0, t.axes[2][0], $tolerance)
+    assert_in_delta(0.0, t.axes[2][1], $tolerance)
+    assert_in_delta(1.0, t.axes[2][2], $tolerance)
+    assert_equal(1, t.atoms.size)
+    assert_equal(
+      InterstitialAtom.new(1, [0.50, 0.50, 0.30]),
+      t.atoms[0]
+    )
+  end
+
+  def test_elements_names
+    atoms = [
+      FrameAtom.new(           0, [0.00, 0.00, 0.00], "A00"),
+      InterstitialAtom.new(0, [0.50, 0.50, 0.50], "A01"),
+      InterstitialAtom.new(1, [0.10, 0.10, 0.10], "A02"),
+      InterstitialAtom.new(2, [0.90, 0.90, 0.90], "A03"),
+      InterstitialAtom.new(3, [0.01, 0.01, 0.01], "A04"),
+      InterstitialAtom.new(3, [0.90, 0.01, 0.01], "A05"),
+      InterstitialAtom.new(3, [0.01, 0.90, 0.01], "A06"),
+      InterstitialAtom.new(3, [0.01, 0.01, 0.90], "A07"),
+      InterstitialAtom.new(4, [0.99, 0.99, 0.99], "A08"),
+      InterstitialAtom.new(4, [0.10, 0.99, 0.99], "A09"),
+      InterstitialAtom.new(4, [0.99, 0.10, 0.99], "A10"),
+      InterstitialAtom.new(4, [0.99, 0.99, 0.10], "A11"),
+      InterstitialAtom.new(5, [0.99, 0.10, 0.10], "A17"),
+      InterstitialAtom.new(5, [0.10, 0.99, 0.10], "A16"),
+      InterstitialAtom.new(5, [0.10, 0.10, 0.99], "A15"),
+      InterstitialAtom.new(5, [0.01, 0.90, 0.90], "A14"),
+      InterstitialAtom.new(5, [0.90, 0.01, 0.90], "A13"),
+      InterstitialAtom.new(5, [0.90, 0.90, 0.01], "A12"),
+    ]                                                                                                   
+    fic = FrameInterstitialCell.new(@lattice_axes, atoms)
+    t = fic.elements_names
+    correct = {
+      0 => ["A00", "A01"],
+      1 => ["A02"],
+      2 => ["A03"],
+      3 => ["A04", "A05", "A06", "A07"],
+      4 => ["A08", "A09", "A10", "A11"],
+      5 => ["A12", "A13", "A14", "A15", "A16", "A17"],
+    }
+    assert_equal(correct, t)
+  end
+
+
+# def test_site_name
+#       # 体心
+#       sitenames_positions = {
+#           "FS_00" => [0.5, 0.5, 0.5],
+#           "FS_01" => [0.0, 0.0, 0.0],
+#       }
+#       log_io = StringIO.new
+#       @fic02 = FrameInterstitialCell.new(@la)
+#
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.51, 0.51, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.40, 0.51, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.51, 0.40, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.51, 0.51, 0.40], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.49, 0.49, 0.49], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_01", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.60, 0.49, 0.49], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_01", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.49, 0.60, 0.49], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_01", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.49, 0.49, 0.60], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_01", t)
+#
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.49, 0.60, 0.60], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Oc_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.60, 0.49, 0.60], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Oc_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.60, 0.60, 0.49], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Oc_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.51, 0.40, 0.40], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Oc_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.40, 0.51, 0.40], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Oc_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.40, 0.40, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Oc_00", t)
+#
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.50, 0.50, 0.50], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("border: Oc_00 Te_00 Te_01", t)
+#
+#       # 内側移動テスト
+#       t = @fic02.site_name(Mageo::Vector3DInternal[9.51, 0.51, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[1.51, 0.51, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.51, 1.51, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[0.51, 0.51, 1.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[-0.49, 0.51, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#       t = @fic02.site_name(Mageo::Vector3DInternal[-9.49, 0.51, 0.51], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("Te_00", t)
+#
+#       # border test
+#       sitenames_positions = { "FS_00" => Mageo::Vector3DInternal[0.0, 0.0, 0.0] }
+#       t = @fic03.site_name(Mageo::Vector3DInternal[0.30, 0.30, 0.00], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("border: Oc_00 Te_00", t)
+#
+#       sitenames_positions = { "FS_00" => Mageo::Vector3DInternal[0.0, 0.0, 0.0] }
+#       t = @fic03.site_name(Mageo::Vector3DInternal[0.30, 0.30, 0.00], sitenames_positions, @oc_sites00, @te_sites00, $tolerance, log_io)
+#       assert_equal("border: Oc_00 Te_00", t)
+#
+# end
+
+  def test_equivalent_cells
+    # テストは全数ではなく、抽出で行う。
+    #    0 交換なし
+    #    1 順序保存(b,c,a)
+    #    3 順序非保存(b,a,c)
+    #    6 c反転
+    # 12 b反転
+    # 24 a反転
+    # 47 順序非保存(c,b,a)+c反転 + b反転 + a反転
+    #
+    lattice_axes = [ [2.0, 2.0, 2.0], [0.0, 2.0, 2.0], [0.0, 0.0, 2.0] ]
+    atoms = [
+      FrameAtom.new(              0, [0.0, 0.0, 0.0] ),
+      InterstitialAtom.new( 1, [0.1, 0.2, 0.3] ),
+    ]
+    fic = FrameInterstitialCell.new(lattice_axes , atoms)
+    fic.comment = 'c01'
+
+    t = fic.equivalent_cells
+    assert_equal(48, t.size)
+
+    cell = t[0]
+    assert_equal("Equivalent cell No.00: Original.", cell.comment)
+    lc = cell.axes.get_lattice_constants
+    assert_in_delta(2.0 * Math::sqrt(3.0), lc[0], $tolerance)
+    assert_in_delta(2.0 * Math::sqrt(2.0), lc[1], $tolerance)
+    assert_in_delta(2.0                                  , lc[2], $tolerance)
+    assert_in_delta(45.0000000000000         , lc[3], $tolerance)
+    assert_in_delta(54.7356103172453         , lc[4], $tolerance)
+    assert_in_delta(35.2643896827547         , lc[5], $tolerance)
+    assert_equal(true, cell.axes.righthand?)
+    assert_equal(Mageo::Vector3DInternal[0.1, 0.2, 0.3], cell.atoms[1].position)
+
+    cell = t[ 1]
+    assert_equal("Equivalent cell No.01: Original -> Axes exchanged(a,b,c -> b,c,a).", cell.comment)
+    lc = cell.axes.get_lattice_constants
+    assert_in_delta(2.0 * Math::sqrt(2.0) , lc[0], $tolerance)
+    assert_in_delta(2.0                                     , lc[1], $tolerance)
+    assert_in_delta(2.0 * Math::sqrt(3.0) , lc[2], $tolerance)
+    assert_in_delta(54.7356103172453            , lc[3], $tolerance)
+    assert_in_delta(35.2643896827547            , lc[4], $tolerance)
+    assert_in_delta(45.0000000000000            , lc[5], $tolerance)
+    assert_equal(true, cell.axes.righthand?)
+    assert_equal(Mageo::Vector3DInternal[0.2, 0.3, 0.1], cell.atoms[1].position)
+
+    cell = t[ 3]
+    assert_equal("Equivalent cell No.03: Original -> Axes exchanged(a,b,c -> b,a,c).", cell.comment)
+    lc = cell.axes.get_lattice_constants
+    assert_in_delta(2.0 * Math::sqrt(2.0) , lc[0], $tolerance)
+    assert_in_delta(2.0 * Math::sqrt(3.0) , lc[1], $tolerance)
+    assert_in_delta(2.0                                     , lc[2], $tolerance)
+    assert_in_delta(54.7356103172453            , lc[3], $tolerance)
+    assert_in_delta(45.0000000000000            , lc[4], $tolerance)
+    assert_in_delta(35.2643896827547            , lc[5], $tolerance)
+    assert_equal(true, cell.axes.lefthand?)
+    assert_equal(Mageo::Vector3DInternal[0.2, 0.1, 0.3], cell.atoms[1].position)
+
+    cell = t[ 6]
+    assert_equal("Equivalent cell No.06: Original -> Axis 'a' inversed.", cell.comment)
+    lc = cell.axes.get_lattice_constants
+    assert_in_delta(2.0 * Math::sqrt(3.0) , lc[0], $tolerance)
+    assert_in_delta(2.0 * Math::sqrt(2.0) , lc[1], $tolerance)
+    assert_in_delta(2.0                                     , lc[2], $tolerance)
+    assert_in_delta(            45.0000000000000, lc[3], $tolerance)
+    assert_in_delta(180.0-54.7356103172453, lc[4], $tolerance)
+    assert_in_delta(180.0-35.2643896827547, lc[5], $tolerance)
+    assert_equal(true, cell.axes.lefthand?)
+    assert_equal(Mageo::Vector3DInternal[-0.1, 0.2, 0.3], cell.atoms[1].position)
+
+    cell = t[12]
+    assert_equal("Equivalent cell No.12: Original -> Axis 'b' inversed.", cell.comment)
+    lc = cell.axes.get_lattice_constants
+    assert_in_delta(2.0 * Math::sqrt(3.0) , lc[0], $tolerance)
+    assert_in_delta(2.0 * Math::sqrt(2.0) , lc[1], $tolerance)
+    assert_in_delta(2.0                                     , lc[2], $tolerance)
+    assert_in_delta(180.0-45.0000000000000, lc[3], $tolerance)
+    assert_in_delta(            54.7356103172453, lc[4], $tolerance)
+    assert_in_delta(180.0-35.2643896827547, lc[5], $tolerance)
+    assert_equal(true, cell.axes.lefthand?)
+    assert_equal(Mageo::Vector3DInternal[0.1,-0.2, 0.3], cell.atoms[1].position)
+
+    cell = t[24]
+    assert_equal("Equivalent cell No.24: Original -> Axis 'c' inversed.", cell.comment)
+    lc = cell.axes.get_lattice_constants
+    assert_in_delta(2.0 * Math::sqrt(3.0) , lc[0], $tolerance)
+    assert_in_delta(2.0 * Math::sqrt(2.0) , lc[1], $tolerance)
+    assert_in_delta(2.0                                     , lc[2], $tolerance)
+    assert_in_delta(180.0-45.0000000000000, lc[3], $tolerance)
+    assert_in_delta(180.0-54.7356103172453, lc[4], $tolerance)
+    assert_in_delta(            35.2643896827547, lc[5], $tolerance)
+    assert_equal(true, cell.axes.lefthand?)
+    assert_equal(Mageo::Vector3DInternal[0.1, 0.2,-0.3], cell.atoms[1].position)
+
+    cell = t[47]
+    assert_equal("Equivalent cell No.47: Original -> Axes exchanged(a,b,c -> c,b,a) -> Axis 'a' inversed -> Axis 'b' inversed -> Axis 'c' inversed.", cell.comment)
+    lc = cell.axes.get_lattice_constants
+    assert_in_delta(2.0                                  , lc[0], $tolerance)
+    assert_in_delta(2.0 * Math::sqrt(2.0), lc[1], $tolerance)
+    assert_in_delta(2.0 * Math::sqrt(3.0), lc[2], $tolerance)
+    assert_in_delta(35.2643896827547         , lc[3], $tolerance)
+    assert_in_delta(54.7356103172453         , lc[4], $tolerance)
+    assert_in_delta(45.0000000000000         , lc[5], $tolerance)
+    assert_equal(false, cell.axes.lefthand?)
+    assert_equal(Mageo::Vector3DInternal[-0.3,-0.2, -0.1], cell.atoms[1].position)
+  end
+end
+
+class TC_CrystalCell_Cell < Test::Unit::TestCase
+  $tolerance = 10 ** (-10)
+
+  def test_to_ficell
+    atoms = [
+      CrystalCell::Atom.new( 'Li', [ 1.2,  3.4,    5.6], "atom0", [ false, false, true] ),
+      CrystalCell::Atom.new( 'O' , [-1.2, -3.4, -5.6] ),
+    ]
+    c08 = CrystalCell::Cell.new([[2.0, 2.0, 2.0], [0.0, 2.0, 2.0], [0.0, 0.0, 2.0]], atoms)
+    c08.comment = 'c08'
+    #
+    t = c08.to_ficell([1])
+    assert_equal( FrameInterstitialCell, t.class )
+    assert_equal( CrystalCell::LatticeAxes, t.axes.class )
+    assert_in_delta( 2.0, t.axes[0][0], $tolerance )
+    assert_in_delta( 2.0, t.axes[0][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[0][2], $tolerance )
+    assert_in_delta( 0.0, t.axes[1][0], $tolerance )
+    assert_in_delta( 2.0, t.axes[1][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[1][2], $tolerance )
+    assert_in_delta( 0.0, t.axes[2][0], $tolerance )
+    assert_in_delta( 0.0, t.axes[2][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[2][2], $tolerance )
+    #
+    assert_equal( 2, t.atoms.size)
+    assert_equal( InterstitialAtom, t.atoms[0].class )
+    assert_equal( FrameAtom             , t.atoms[1].class )
+    assert_in_delta( 1.2, t.atoms[0].position[0], $tolerance )
+    assert_in_delta( 3.4, t.atoms[0].position[1], $tolerance )
+    assert_in_delta( 5.6, t.atoms[0].position[2], $tolerance )
+    assert_in_delta(-1.2, t.atoms[1].position[0], $tolerance )
+    assert_in_delta(-3.4, t.atoms[1].position[1], $tolerance )
+    assert_in_delta(-5.6, t.atoms[1].position[2], $tolerance )
+    #
+    assert_equal( "atom0", t.atoms[0].name )
+    assert_equal( nil        , t.atoms[1].name )
+    #
+    assert_equal( [ false, false, true  ], t.atoms[0].movable_flags )
+    assert_equal( nil, t.atoms[1].movable_flags )
+    #
+    assert_equal( "c08", t.comment )
+
+    atoms = [
+      CrystalCell::Atom.new( 'Li', [ 1.2,  3.4,    5.6], "atom0", [ false, false, true] ),
+      CrystalCell::Atom.new( 'O' , [-1.2, -3.4, -5.6] ),
+    ]
+    c08 = CrystalCell::Cell.new([[2.0, 2.0, 2.0], [0.0, 2.0, 2.0], [0.0, 0.0, 2.0]], atoms)
+    c08.comment = 'c08'
+    #
+    t = c08.to_ficell([])
+    assert_equal( FrameInterstitialCell, t.class )
+    assert_equal( CrystalCell::LatticeAxes, t.axes.class )
+    assert_in_delta( 2.0, t.axes[0][0], $tolerance )
+    assert_in_delta( 2.0, t.axes[0][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[0][2], $tolerance )
+    assert_in_delta( 0.0, t.axes[1][0], $tolerance )
+    assert_in_delta( 2.0, t.axes[1][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[1][2], $tolerance )
+    assert_in_delta( 0.0, t.axes[2][0], $tolerance )
+    assert_in_delta( 0.0, t.axes[2][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[2][2], $tolerance )
+    #
+    assert_equal( 2, t.atoms.size)
+    assert_equal( InterstitialAtom, t.atoms[0].class )
+    assert_equal( InterstitialAtom, t.atoms[1].class )
+    assert_in_delta( 1.2, t.atoms[0].position[0], $tolerance )
+    assert_in_delta( 3.4, t.atoms[0].position[1], $tolerance )
+    assert_in_delta( 5.6, t.atoms[0].position[2], $tolerance )
+    assert_in_delta(-1.2, t.atoms[1].position[0], $tolerance )
+    assert_in_delta(-3.4, t.atoms[1].position[1], $tolerance )
+    assert_in_delta(-5.6, t.atoms[1].position[2], $tolerance )
+    #
+    assert_equal( "atom0", t.atoms[0].name )
+    assert_equal( nil        , t.atoms[1].name )
+    #
+    assert_equal( [ false, false, true  ], t.atoms[0].movable_flags )
+    assert_equal( nil, t.atoms[1].movable_flags )
+    #
+    assert_equal( "c08", t.comment )
+
+
+    atoms = [
+      CrystalCell::Atom.new( 'Li', [ 1.2,  3.4,    5.6], "atom0", [ false, false, true] ),
+      CrystalCell::Atom.new( 'O' , [-1.2, -3.4, -5.6] ),
+    ]
+    c08 = CrystalCell::Cell.new([[2.0, 2.0, 2.0], [0.0, 2.0, 2.0], [0.0, 0.0, 2.0]], atoms)
+    c08.comment = 'c08'
+    #
+    t = c08.to_ficell
+    assert_equal( FrameInterstitialCell, t.class )
+    assert_equal( CrystalCell::LatticeAxes, t.axes.class )
+    assert_in_delta( 2.0, t.axes[0][0], $tolerance )
+    assert_in_delta( 2.0, t.axes[0][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[0][2], $tolerance )
+    assert_in_delta( 0.0, t.axes[1][0], $tolerance )
+    assert_in_delta( 2.0, t.axes[1][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[1][2], $tolerance )
+    assert_in_delta( 0.0, t.axes[2][0], $tolerance )
+    assert_in_delta( 0.0, t.axes[2][1], $tolerance )
+    assert_in_delta( 2.0, t.axes[2][2], $tolerance )
+    #
+    assert_equal( 2, t.atoms.size)
+    assert_equal( FrameAtom, t.atoms[0].class )
+    assert_equal( FrameAtom, t.atoms[1].class )
+    assert_in_delta( 1.2, t.atoms[0].position[0], $tolerance )
+    assert_in_delta( 3.4, t.atoms[0].position[1], $tolerance )
+    assert_in_delta( 5.6, t.atoms[0].position[2], $tolerance )
+    assert_in_delta(-1.2, t.atoms[1].position[0], $tolerance )
+    assert_in_delta(-3.4, t.atoms[1].position[1], $tolerance )
+    assert_in_delta(-5.6, t.atoms[1].position[2], $tolerance )
+    #
+    assert_equal( "atom0", t.atoms[0].name )
+    assert_equal( nil        , t.atoms[1].name )
+    #
+    assert_equal( [ false, false, true  ], t.atoms[0].movable_flags )
+    assert_equal( nil, t.atoms[1].movable_flags )
+    #
+    assert_equal( "c08", t.comment )
+
+  end
+
+end