crysna 0.0.4

data/test/test_siteoperation.rb

@@ -0,0 +1,79 @@
+##! /usr/bin/env ruby
+## coding: utf-8
+#
+#require "yaml"
+#require "helper"
+##require "test/unit"
+##require "crysna/siteoperation.rb"
+#
+#class TC_SiteOperation< Test::Unit::TestCase
+#  #def setup
+#  # @so00 = Crysna::SiteOperation.new
+#  #end
+#  
+#  def test_site_operation
+#    sites = {
+#      "FS_00" => [ 0.0, 0.0, 0.00 ],
+#      "FS_01" => [ 0.0, 0.0, 0.25 ],
+#      "FS_02" => [ 0.0, 0.0, 0.50 ],
+#      "FS_03" => [ 0.0, 0.0, 0.75 ],
+#    }
+#
+#    operations = [
+#      { "rotation" => [
+#          [  1,  0,  0],
+#          [  0,  1,  0],
+#          [  0,  0,  1],
+#        ],
+#        "translation" => [  0.00,  0.00,  0.00]
+#      },{ "rotation" => [
+#          [  1,  0,  0],
+#          [  0,  1,  0],
+#          [  0,  0,  1],
+#        ],
+#        "translation" => [  0.00,  0.00,  0.25]
+#      },{ "rotation" => [
+#          [  1,  0,  0],
+#          [  0,  1,  0],
+#          [  0,  0, -1],
+#        ],
+#        "translation" => [  0.00,  0.00,  0.00]
+#      },{ "rotation" => [
+#          [  1,  0,  0],
+#          [  0,  1,  0],
+#          [  0,  0, -1],
+#        ],
+#        "translation" => [  0.00,  0.00,  0.25]
+#      }
+#    ]
+#    results = Crysna::SiteOperation.site_operation(sites, operations)
+#    corrects = [
+#      {
+#        "FS_00" => ["FS_00", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1],]],
+#        "FS_01" => ["FS_01", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1],]],
+#        "FS_02" => ["FS_02", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1],]],
+#        "FS_03" => ["FS_03", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1],]],
+#      }, {
+#        "FS_00" => ["FS_01", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1],]],
+#        "FS_01" => ["FS_02", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1],]],
+#        "FS_02" => ["FS_03", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1],]],
+#        "FS_03" => ["FS_00", [ 0, 0, 1], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1],]],
+#      }, {
+#        "FS_00" => ["FS_00", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0,-1],]],
+#        "FS_01" => ["FS_03", [ 0, 0,-1], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0,-1],]],
+#        "FS_02" => ["FS_02", [ 0, 0,-1], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0,-1],]],
+#        "FS_03" => ["FS_01", [ 0, 0,-1], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0,-1],]],
+#      }, {
+#        "FS_00" => ["FS_01", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0,-1],]],
+#        "FS_01" => ["FS_00", [ 0, 0, 0], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0,-1],]],
+#        "FS_02" => ["FS_03", [ 0, 0,-1], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0,-1],]],
+#        "FS_03" => ["FS_02", [ 0, 0,-1], [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0,-1],]],
+#      }
+#    ]
+#    corrects.size.times do |index|
+#      assert_equal(corrects[index], results[index], "#{index}th")
+#    end
+#    assert_equal(corrects.size, results.size)
+#  end
+#end
+#

data/test/test_sitewithposition.rb

@@ -0,0 +1,20 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class TC_SiteWithPosition < Test::Unit::TestCase
+  def setup
+    @cs_S00_m01_123 = Crysna::SiteWithPosition.new("S00", [-1, 0, 1], [0.1, 0.2, 0.3])
+  end
+
+  def test_internal_vector
+    assert_equal(Mageo::Vector3DInternal[0.1, 0.2, 0.3], @cs_S00_m01_123.internal_vector)
+  end
+
+  def test_coordinates
+    assert_equal(Mageo::Vector3DInternal[-0.9, 0.2, 1.3], @cs_S00_m01_123.coordinates)
+  end
+end

data/test/test_transitionfinder.rb

@@ -0,0 +1,432 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class Crysna::TransitionFinder::Cell
+  attr_accessor :atoms
+  attr_accessor :reach_flag
+end
+
+class Crysna::TransitionFinder
+  public :reach_unreach_edges
+  public :find_periodically_candidate
+  public :from_to_node_indices
+  public :expand_edges
+  public :minimum_operation
+  public :two_indices
+  public :each_sort
+  attr_accessor :edges
+  attr_accessor :cell_manager
+end
+
+class TC_TransitionFinder < Test::Unit::TestCase
+  CTCell = Crysna::TransitionFinder::Cell
+
+  ATOM_A4 = Crysna::Atom.new(0, "A", [-1,0,0])
+  ATOM_B4 = Crysna::Atom.new(0, "B", [-1,0,0])
+  ATOM_C4 = Crysna::Atom.new(0, "C", [-1,0,0])
+  ATOM_D4 = Crysna::Atom.new(0, "D", [-1,0,0])
+  ATOM_E4 = Crysna::Atom.new(1, "E", [-1,0,0])
+  ATOM_F4 = Crysna::Atom.new(1, "F", [-1,0,0])
+  ATOM_G4 = Crysna::Atom.new(1, "G", [-1,0,0])
+
+  ATOM_A5 = Crysna::Atom.new(0, "A", [0,0,0])
+  ATOM_B5 = Crysna::Atom.new(0, "B", [0,0,0])
+  ATOM_C5 = Crysna::Atom.new(0, "C", [0,0,0])
+  ATOM_D5 = Crysna::Atom.new(0, "D", [0,0,0])
+  ATOM_E5 = Crysna::Atom.new(1, "E", [0,0,0])
+  ATOM_F5 = Crysna::Atom.new(1, "F", [0,0,0])
+  ATOM_G5 = Crysna::Atom.new(1, "G", [0,0,0])
+
+  ATOM_A6 = Crysna::Atom.new(0, "A", [1,0,0])
+  ATOM_B6 = Crysna::Atom.new(0, "B", [1,0,0])
+  ATOM_C6 = Crysna::Atom.new(0, "C", [1,0,0])
+  ATOM_D6 = Crysna::Atom.new(0, "D", [1,0,0])
+  ATOM_E6 = Crysna::Atom.new(1, "E", [1,0,0])
+  ATOM_F6 = Crysna::Atom.new(1, "F", [1,0,0])
+  ATOM_G6 = Crysna::Atom.new(1, "G", [1,0,0])
+
+  SITE_MIG = {
+    "A"=>[["D", [-1, 0, 0]], ["B", [0, 0, 0]]],
+    "B"=>[["A", [0, 0, 0]], ["C", [0, 0, 0]]],
+    "C"=>[["B", [0, 0, 0]], ["D", [0, 0, 0]]],
+    "D"=>[["C", [0, 0, 0]], ["A", [1, 0, 0]]],
+    "E"=>[["F", [0, 0, 0]]],
+    "F"=>[["E", [0, 0, 0]], ["F", [0, 0, 0]]],
+    "G"=>[["F", [0, 0, 0]]]
+  }
+
+  SITE_OPE = [
+    {
+      "operation_id"=> 0,
+      "operation"=> {
+        "A"=>["A", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "B"=>["B", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "C"=>["C", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "D"=>["D", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "E"=>["E", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "F"=>["F", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "G"=>["G", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]],
+      }
+    } , {
+      "operation_id"=> 1,
+      "operation"=> {
+        "A"=>["D", [0, 0, 0], [[-1, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "B"=>["C", [0, 0, 0], [[-1, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "C"=>["B", [0, 0, 0], [[-1, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "D"=>["A", [0, 0, 0], [[-1, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "E"=>["G", [0, 0, 0], [[-1, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "F"=>["F", [0, 0, 0], [[-1, 0, 0], [0, 0, 0], [0, 0, 0]]],
+        "G"=>["E", [0, 0, 0], [[-1, 0, 0], [0, 0, 0], [0, 0, 0]]],
+      }
+    }
+  ]
+
+  ENERGY_ABE = 0.0
+  ENERGY_ABF = 6.0
+  ENERGY_ACE = 1.0
+  ENERGY_ACF = 7.0
+  ENERGY_ADE = 2.0
+  ENERGY_ADF = 8.0
+  ENERGY_BCE = 3.0
+  ENERGY_BCF = 9.0
+  ENERGY_BDE = 4.0
+  ENERGY_CDE = 5.0
+  ENERGY_OTHER = Float::INFINITY
+
+  def setup
+    ##memo, all is (4x3/2) *3 = 18 
+    ##ABE ABF ABG
+    ##ACE ACF ACG
+    ##ADE ADF ADG
+    ##BCE BCF BCG
+    ##BDE BDF BDG
+    ##CDE CDF CDG
+    @cell_ABE = CTCell.new({0=>["A", "B"], 1=>["E"]},ENERGY_ABE,"A555-B555-E555")
+    @cell_ABF = CTCell.new({0=>["A", "B"], 1=>["F"]},ENERGY_ABF,"A555-B555-F555")
+   #@cell_ABG is not included. identical to CDE
+    @cell_ACE = CTCell.new({0=>["A", "C"], 1=>["E"]},ENERGY_ACE,"A555-C555-E555")
+    @cell_ACF = CTCell.new({0=>["A", "C"], 1=>["F"]},ENERGY_ACF,"A555-C555-F555")
+   #@cell_ACG is not included. identical to BDE
+    @cell_ADE = CTCell.new({0=>["A", "D"], 1=>["E"]},ENERGY_ADE,"A555-D555-E555")
+    @cell_ADF = CTCell.new({0=>["A", "D"], 1=>["F"]},ENERGY_ADF,"A555-D555-F555")
+   #@cell_ADG is not included. identical to ADE
+    @cell_BCE = CTCell.new({0=>["B", "C"], 1=>["E"]},ENERGY_BCE,"B555-C555-E555")
+    @cell_BCF = CTCell.new({0=>["B", "C"], 1=>["F"]},ENERGY_BCF,"B555-C555-F555")
+   #@cell_BCG is not included. identical to BCE
+    @cell_BDE = CTCell.new({0=>["B", "D"], 1=>["E"]},ENERGY_BDE,"B555-D555-E555")
+   #@cell_BDF is not included. identical to ACF
+   #@cell_BDG is not included. identical to ACE
+    @cell_CDE = CTCell.new({0=>["C", "D"], 1=>["E"]},ENERGY_CDE,"C555-D555-E555")
+   #@cell_CDF is not included. identical to ABF
+   #@cell_CDG is not included. identical to ABE
+
+    cells = [
+      @cell_ABE,
+      @cell_ABF,
+      @cell_ACE,
+      @cell_ACF,
+      @cell_ADE,
+      @cell_ADF,
+      @cell_BCE,
+      @cell_BCF,
+      @cell_BDE,
+      @cell_CDE,
+    ]
+
+    @edges = [
+      Crysna::TransitionFinder::Edge.new([0, 1], 0.0, "0->1"), #false-false
+      Crysna::TransitionFinder::Edge.new([0, 2], 0.0, "0->2"), #false-true 
+      Crysna::TransitionFinder::Edge.new([2, 0], 0.0, "2->0"), #true -false
+      Crysna::TransitionFinder::Edge.new([2, 3], 0.0, "2->3"), #true -true 
+    ]
+
+    @t00 = Crysna::TransitionFinder.new(cells, SITE_MIG, SITE_OPE)
+    @t01 = Crysna::TransitionFinder.new(cells, SITE_MIG, SITE_OPE)
+    @t01.edges = @edges
+    @t01.cell_manager.add @cell_ABE
+    @t01.cell_manager.add @cell_ACE
+    @t01.cell_manager.add @cell_ADE
+    @t01.cell_manager.add @cell_BCE
+
+    $log_io = StringIO.new
+  end
+
+  #def test_initialize
+  #    @t00
+  #end
+
+  def test_find_path
+    result_io = StringIO.new
+    dot_io = StringIO.new
+    t = @t00.find_path("A555-B555-E555", false, result_io, dot_io)
+    result_io.rewind
+    #puts result_io.read
+
+    correct = <<HERE
+------------------------------------------------------------
+One direction
+[cell]
+    atoms: 0:A555-B555,1:E555
+    symmetrically identical cell: 0:A-B,1:E(operation_id=0)
+    energy: 0.0
+|
+|[migration] elem=0, A -> D[-1, 0, 0]
+|
+[cell]
+    atoms: 0:B555-D455,1:E555
+    symmetrically identical cell: 0:A-C,1:G(operation_id=1)
+    energy: 4.0
+------------------------------------------------------------
+The other direction
+[cell]
+    atoms: 0:A555-B555,1:E555
+    symmetrically identical cell: 0:A-B,1:E(operation_id=0)
+    energy: 0.0
+|
+|[migration] elem=0, B -> C[0, 0, 0]
+|
+[cell]
+    atoms: 0:A555-C555,1:E555
+    symmetrically identical cell: 0:A-C,1:E(operation_id=0)
+    energy: 1.0
+|
+|[migration] elem=0, C -> D[0, 0, 0]
+|
+[cell]
+    atoms: 0:A555-D555,1:E555
+    symmetrically identical cell: 0:A-D,1:E(operation_id=0)
+    energy: 2.0
+|
+|[migration] elem=0, A -> B[0, 0, 0]
+|
+[cell]
+    atoms: 0:B555-D555,1:E555
+    symmetrically identical cell: 0:A-C,1:G(operation_id=1)
+    energy: 4.0
+HERE
+    assert_equal(correct, result_io.read)
+
+    dot_io.rewind
+    #puts dot_io.read
+
+    #puts "経路がないときの終了条件。"
+    #puts "等価なサイトに到達したあとにnew edge を伸ばさない仕組み。"
+    #assert(false)
+    #
+  end
+
+  def test_reach_unreach_edges
+    @cell_ADE.reach_flag = true  #2
+    @cell_BCE.reach_flag = true  #3
+    assert_equal(
+      [
+        Crysna::TransitionFinder::Edge.new([0, 2], 0.0, "0->2"),
+        Crysna::TransitionFinder::Edge.new([2, 0], 0.0, "2->0"),
+      ],
+      @t01.reach_unreach_edges
+    )
+  end
+
+  def test_find_periodically_candidate
+    cell_A5B4E5 = CTCell.new({}, ENERGY_ABE, "A5B4E5") ; cell_A5B4E5.atoms = [ATOM_A5, ATOM_B4, ATOM_E5]
+    cell_A6B5E5 = CTCell.new({}, ENERGY_ABE, "A6B5E5") ; cell_A6B5E5.atoms = [ATOM_A6, ATOM_B5, ATOM_E5]
+    cell_A5D4E5 = CTCell.new({}, ENERGY_ADE, "A5D4E5") ; cell_A5D4E5.atoms = [ATOM_A5, ATOM_D4, ATOM_E5]
+    cell_A5C4E5 = CTCell.new({}, ENERGY_ACE, "A5C4E5") ; cell_A5C4E5.atoms = [ATOM_A5, ATOM_C4, ATOM_E5]
+    cell_B5D4E5 = CTCell.new({}, ENERGY_BDE, "B5D4E5") ; cell_B5D4E5.atoms = [ATOM_B5, ATOM_D4, ATOM_E5]
+
+    assert_equal(0, @t00.find_periodically_candidate(@cell_ABE ))
+    assert_equal(0, @t00.find_periodically_candidate(cell_A5B4E5))
+    assert_equal(0, @t00.find_periodically_candidate(cell_A6B5E5))
+    assert_equal(1, @t00.find_periodically_candidate(@cell_ABF ))
+    assert_equal(2, @t00.find_periodically_candidate(@cell_ACE ))
+    assert_equal(2, @t00.find_periodically_candidate(cell_A5C4E5))
+    assert_equal(3, @t00.find_periodically_candidate(@cell_ACF ))
+    assert_equal(4, @t00.find_periodically_candidate(@cell_ADE ))
+    assert_equal(4, @t00.find_periodically_candidate(cell_A5D4E5))
+    assert_equal(5, @t00.find_periodically_candidate(@cell_ADF ))
+    assert_equal(6, @t00.find_periodically_candidate(@cell_BCE ))
+    assert_equal(7, @t00.find_periodically_candidate(@cell_BCF ))
+    assert_equal(8, @t00.find_periodically_candidate(@cell_BDE ))
+    assert_equal(8, @t00.find_periodically_candidate(cell_B5D4E5))
+    assert_equal(9, @t00.find_periodically_candidate(@cell_CDE ))
+
+    cell = CTCell.new({0=>["A", "A"], 1=>["E"]}, 0.0)
+    assert_equal(nil, @t00.find_periodically_candidate(cell))
+
+  end
+
+  def test_from_to_node_indices
+    @cell_ADE.reach_flag = true  #2
+    @cell_BCE.reach_flag = true  #3
+    assert_equal([2, 0], @t01.from_to_node_indices(@edges[1]))
+    assert_equal([2, 0], @t01.from_to_node_indices(@edges[2]))
+    assert_raise(RuntimeError){@t01.from_to_node_indices(@edges[0])}
+    assert_raise(RuntimeError){@t01.from_to_node_indices(@edges[3])}
+  end
+
+  def test_expand_edges
+    cell_B5D4E5 = CTCell.new({}, ENERGY_BDE, "B555-D455-E555") ; cell_B5D4E5.atoms = [ATOM_B5, ATOM_D4, ATOM_E5]
+    cell_BBE = CTCell.new({}, ENERGY_OTHER, "B555-B555-E555") ; cell_BBE.atoms = [ATOM_B5, ATOM_B5, ATOM_E5]
+    cell_AAE = CTCell.new({}, ENERGY_OTHER, "A555-A555-E555") ; cell_AAE.atoms = [ATOM_A5, ATOM_A5, ATOM_E5]
+
+    ## before expand_edges ##############################
+    @t00.cell_manager.add(@cell_ABE)
+    @t00.cell_manager.reach(0, nil)
+    assert_equal(1, @t00.cell_manager.cells.size)
+    assert_equal(0, @t00.edges.size)
+
+    @t00.expand_edges(0)
+
+    ## 1st expand_edges ##############################
+    ## should be
+    ## cell_manager
+    ##@t00.cell_manager.cells.each {|cell| puts cell.occupied_sitename}
+    ##=>
+    ##A555-B555-E555 #[0]
+    ##B555-D455-E555 #[1]
+    ##B555-B555-E555 #[2]
+    ##A555-A555-E555 #[3]
+    ##A555-C555-E555 #[4]
+    ##A555-B555-F555 #[5]
+
+    ## @t00.edges ...
+    ## [#<Crysna::TransitionFinder::Edge:0x000000022a48b8
+    ## =>
+    ## [0, 1],
+    ## [0, 2],
+    ## [0, 3],
+    ## [0, 4],
+    ## [0, 5],
+
+    assert_equal(1+5, @t00.cell_manager.cells.size)
+    assert_equal(5, @t00.edges.size)
+    assert_equal(@cell_ABE,    @t00.cell_manager[0])
+    assert_equal( cell_B5D4E5, @t00.cell_manager[1])
+    assert_equal( cell_BBE,    @t00.cell_manager[2])
+    assert_equal( cell_AAE,    @t00.cell_manager[3])
+    assert_equal(@cell_ACE,    @t00.cell_manager[4])
+    assert_equal(@cell_ABF,    @t00.cell_manager[5])
+
+    assert_equal(ENERGY_ABE,   @t00.cell_manager[0].energy)
+    assert_equal(ENERGY_BDE,   @t00.cell_manager[1].energy)
+    assert_equal(ENERGY_OTHER, @t00.cell_manager[2].energy)
+    assert_equal(ENERGY_OTHER, @t00.cell_manager[3].energy)
+    assert_equal(ENERGY_ACE,   @t00.cell_manager[4].energy)
+    assert_equal(ENERGY_ABF,   @t00.cell_manager[5].energy)
+
+    assert_equal(0+5, @t00.edges.size)
+    assert_equal([0,1], @t00.edges[0].nodes)
+    assert_equal([0,2], @t00.edges[1].nodes)
+    assert_equal([0,3], @t00.edges[2].nodes)
+    assert_equal([0,4], @t00.edges[3].nodes)
+    assert_equal([0,5], @t00.edges[4].nodes)
+
+    assert_equal(ENERGY_BDE  , @t00.edges[0].weight)
+    assert_equal(ENERGY_OTHER, @t00.edges[1].weight)
+    assert_equal(ENERGY_OTHER, @t00.edges[2].weight)
+    assert_equal(ENERGY_ACE  , @t00.edges[3].weight)
+    assert_equal(ENERGY_ABF  , @t00.edges[4].weight)
+
+    ## 2nd expand_edges ##############################
+    ## should be
+    ## cell_manager
+    ##@t00.cell_manager.cells.each {|cell| puts cell.occupied_sitename}
+    ##=>
+    ##A555-B555-E555 #[0]
+    ##B555-D455-E555 #[1]
+    ##B555-B555-E555 #[2]
+    ##A555-A555-E555 #[3]
+    ##A555-C555-E555 #[4]
+    ##A555-B555-F555 #[5]
+    ##B555-C555-E555 #[6] new
+    ##C555-D455-E555 #[7] new
+    ##A555-D555-E555 #[8] new
+    ##A555-C555-F555 #[9] new
+
+    ## @t00.edges ...
+    ## [#<Crysna::TransitionFinder::Edge:0x000000022a48b8
+    ## =>
+    ## [0, 1], #[0] 
+    ## [0, 2], #[1] 
+    ## [0, 3], #[2] 
+    ## [0, 4], #[3] 
+    ## [0, 5], #[4] 
+    ## [4, 6], #[5] new
+    ## [4, 7], #[6] new
+    ## [4, 8], #[7] new
+    ## [4, 9], #[8] new
+    ## [4, 0],   is not included due to duplicated to [0]
+    #
+    cell_C5D4E5 = CTCell.new({}, ENERGY_CDE, "C555-D455-E555") ; cell_C5D4E5.atoms = [ATOM_C5, ATOM_D4, ATOM_E5]
+
+    @t00.expand_edges(4)
+    assert_equal(@cell_ABE,    @t00.cell_manager[0])
+    assert_equal( cell_B5D4E5, @t00.cell_manager[1])
+    assert_equal( cell_BBE,    @t00.cell_manager[2])
+    assert_equal( cell_AAE,    @t00.cell_manager[3])
+    assert_equal(@cell_ACE,    @t00.cell_manager[4])
+    assert_equal(@cell_ABF,    @t00.cell_manager[5])
+    assert_equal( cell_C5D4E5, @t00.cell_manager[6])
+    assert_equal(@cell_BCE,    @t00.cell_manager[7])
+    assert_equal(@cell_ADE,    @t00.cell_manager[8])
+    assert_equal(@cell_ACF,    @t00.cell_manager[9])
+
+    assert_equal(ENERGY_ABE,   @t00.cell_manager[0].energy)
+    assert_equal(ENERGY_BDE,   @t00.cell_manager[1].energy)
+    assert_equal(ENERGY_OTHER, @t00.cell_manager[2].energy)
+    assert_equal(ENERGY_OTHER, @t00.cell_manager[3].energy)
+    assert_equal(ENERGY_ACE,   @t00.cell_manager[4].energy)
+    assert_equal(ENERGY_ABF,   @t00.cell_manager[5].energy)
+    assert_equal(ENERGY_CDE,   @t00.cell_manager[6].energy)
+    assert_equal(ENERGY_BCE,   @t00.cell_manager[7].energy)
+    assert_equal(ENERGY_ADE,   @t00.cell_manager[8].energy)
+    assert_equal(ENERGY_ACF,   @t00.cell_manager[9].energy)
+
+    #pp @t00.edges.map {|edge| edge.nodes}
+    assert_equal([0,1], @t00.edges[0].nodes)
+    assert_equal([0,2], @t00.edges[1].nodes)
+    assert_equal([0,3], @t00.edges[2].nodes)
+    assert_equal([0,4], @t00.edges[3].nodes)
+    assert_equal([0,5], @t00.edges[4].nodes)
+    assert_equal([4,6], @t00.edges[5].nodes)
+    assert_equal([4,7], @t00.edges[6].nodes)
+    assert_equal([4,8], @t00.edges[7].nodes)
+    assert_equal([4,9], @t00.edges[8].nodes)
+
+    assert_equal(ENERGY_BDE  , @t00.edges[0].weight)
+    assert_equal(ENERGY_OTHER, @t00.edges[1].weight)
+    assert_equal(ENERGY_OTHER, @t00.edges[2].weight)
+    assert_equal(ENERGY_ACE  , @t00.edges[3].weight)
+    assert_equal(ENERGY_ABF  , @t00.edges[4].weight)
+    assert_equal(ENERGY_CDE  , @t00.edges[5].weight)#ACE,CDE
+    assert_equal(ENERGY_BCE  , @t00.edges[6].weight)#ACE,BCE
+    assert_equal(ENERGY_ADE  , @t00.edges[7].weight)#ACE,ADE 
+    assert_equal(ENERGY_ACF  , @t00.edges[8].weight)#ACE,ACF
+
+    assert_equal(1+5+4, @t00.cell_manager.cells.size)
+    assert_equal(0+5+4, @t00.edges.size)
+  end
+
+  def test_minimum_operation
+    result_io = StringIO.new
+    #assert_equal(0, @t00.minimum_operation(@cell_ACE))
+
+    cell_bdg = CTCell.new({0=>["B", "D"], 1=>["G"]}, 0.0, "BDG")
+    assert_equal(1, @t00.minimum_operation(cell_bdg))
+  end
+
+  def test_two_indices
+    assert_equal( [ [0,2], [2,4], [4,6]],
+                 @t00.two_indices([0,2,4,6]))
+  end
+
+  def test_each_sort
+    assert_equal( [ [0,2], [2,4], [4,6]],
+                 @t00.each_sort( [ [0,2], [4,2], [4,6]]))
+  end
+end
+