crysna 0.0.4

data/test/transitionfinder/collectcells.yaml

@@ -0,0 +1,81 @@
+---
+'ABE':
+  sites:
+    0:
+      - A
+      - B
+    1:
+    - E
+  toten: 0.0
+'ACE':
+  sites:
+    0:
+      - A
+      - C
+    1:
+    - E
+  toten: 1.0
+'ADE':
+  sites:
+    0:
+      - A
+      - D
+    1:
+    - E
+  toten: 2.0
+'BCE':
+  sites:
+    0:
+      - B
+      - C
+    1:
+    - E
+  toten: 3.0
+'BDE':
+  sites:
+    0:
+      - B
+      - D
+    1:
+    - E
+  toten: 4.0
+'CDE':
+  sites:
+    0:
+      - C
+      - D
+    1:
+    - E
+  toten: 5.0
+'ABF':
+  sites:
+    0:
+      - A
+      - B
+    1:
+    - F
+  toten: 6.0
+'ACF':
+  sites:
+    0:
+      - A
+      - C
+    1:
+    - F
+  toten: 7.0
+'ADF':
+  sites:
+    0:
+      - A
+      - D
+    1:
+    - F
+  toten: 8.0
+'BCF':
+  sites:
+    0:
+      - B
+      - C
+    1:
+    - F
+  toten: 9.0

data/test/transitionfinder/sitemigrations.yaml

@@ -0,0 +1,33 @@
+---
+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
+  - [  1,  0,  0 ]
+- - A
+  - [  0,  0,  0 ]
+E:
+- - F
+  - [  0,  0,  0 ]
+F:
+- - E
+  - [  0,  0,  0 ]
+- - F
+  - [  0,  0,  0 ]
+G:
+- - F
+  - [  0,  0,  0 ]
+

data/test/transitionfinder/siteoperations.yaml

@@ -0,0 +1,16 @@
+---
+- 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]]]
+- A: ["D", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
+  B: ["C", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
+  C: ["B", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
+  D: ["A", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
+  E: ["G", [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: ["E", [0, 0, 0], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
+

data/test/transitionfinder/test_cell.rb

@@ -0,0 +1,287 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+#require "test/unit"
+#require "pkg/klass.rb"
+
+class Crysna::Cell
+  attr_accessor :atoms
+  attr_accessor :reach_flag
+  attr_accessor :from_edges
+end
+
+class TC_TFCell < Test::Unit::TestCase
+  def setup
+    @cell00 = Crysna::TransitionFinder::Cell.new(
+      { 0 => ["A", "B"], 1 => ["E"]}, -10.0)
+
+    atoms = [
+      Crysna::Atom.new(0, "A", [1, 0, 0]),
+      Crysna::Atom.new(0, "B", [1, 0, 0]),
+      Crysna::Atom.new(1, "F", [1, 0, 0]),
+    ]
+    @cell01 = Crysna::TransitionFinder::Cell.new({}, -11.0)
+    @cell01.atoms = atoms
+    @cell02 = Crysna::TransitionFinder::Cell.new({}, -11.0, "abc")
+    @cell02.atoms = atoms
+  end
+
+  def test_equal
+    assert_equal(true , @cell00 == @cell00)
+    assert_equal(true , @cell01 == @cell01)
+    assert_equal(true , @cell02 == @cell02)
+    assert_equal(false, @cell00 == @cell01)
+    assert_equal(false, @cell01 == @cell02)
+    assert_equal(false, @cell02 == @cell00)
+  end
+
+  def test_same_atoms?
+    cell = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    assert_equal(true, @cell00.same_atoms?(cell))
+
+    cell = Crysna::TransitionFinder::Cell.new({}, -11.0)
+    cell.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    assert_equal(true, @cell00.same_atoms?(cell))
+
+    cell = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell.atoms = [
+      Crysna::Atom.new(0, "A", [1, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    assert_equal(false, @cell00.same_atoms?(cell))
+
+    cell = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "C", [0, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    assert_equal(false, @cell00.same_atoms?(cell))
+
+    cell = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(0, "E", [0, 0, 0]),
+    ]
+    assert_equal(false, @cell00.same_atoms?(cell))
+
+    cell = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    cell.reach_flag = true
+    assert_equal(true, @cell00.same_atoms?(cell))
+
+    cell = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    cell.from_edges = [nil]
+    assert_equal(true, @cell00.same_atoms?(cell))
+
+    cell = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    cell.name = "something"
+    assert_equal(true, @cell00.same_atoms?(cell))
+  end
+
+  def test_same_sites?
+    assert_equal(true , @cell00.same_sites?(@cell00))
+    assert_equal(true , @cell01.same_sites?(@cell01))
+    assert_equal(true , @cell02.same_sites?(@cell02))
+    assert_equal(false, @cell00.same_sites?(@cell01))
+    assert_equal(true , @cell01.same_sites?(@cell02))
+    assert_equal(false, @cell02.same_sites?(@cell00))
+
+    atoms = [
+      Crysna::Atom.new(0, "A", [1, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(1, "F", [1, 0, 0]),
+    ]
+    cell = Crysna::TransitionFinder::Cell.new({}, -11.0)
+    cell.atoms = atoms
+    assert_equal(true , @cell01.same_sites?(cell))
+  end
+
+  def test_name
+    assert_equal("", @cell00.name)
+    assert_equal("", @cell01.name)
+    assert_equal("abc", @cell02.name)
+
+    cell = Crysna::TransitionFinder::Cell.new(
+      { 0 => ["A", "B"], 1 => ["E"]}, -10.0, "abc")
+    assert_equal("abc", cell.name)
+  end
+
+  def test_migrate!
+    @cell01.migrate!(0, "C", [-1, 1, -1])
+    atoms = @cell01.atoms
+    assert_equal(Crysna::Atom.new(0, "B", [1,0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(0, "C", [0,1,-1]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "F", [1,0, 0]), atoms.shift)
+    assert_equal(nil                                                                     , atoms.shift)
+
+    assert_raise(Crysna::TransitionFinder::Cell::RangeError){
+      @cell01.migrate!(3, "C", [-1, 1, -1])
+    }
+  end
+
+  def test_migrate
+    result = @cell01.migrate(0, "C", [-1, 1, -1])
+    atoms = @cell01.atoms
+    assert_equal(Crysna::Atom.new(0, "A", [1,0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(0, "B", [1,0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "F", [1,0, 0]), atoms.shift)
+    assert_equal(nil                                                                     , atoms.shift)
+
+    atoms = result.atoms
+    assert_equal(Crysna::Atom.new(0, "B", [1,0, 0]), atoms.shift)
+    assert_equal(Crysna::Atom.new(0, "C", [0,1,-1]), atoms.shift)
+    assert_equal(Crysna::Atom.new(1, "F", [1,0, 0]), atoms.shift)
+    assert_equal(nil                                                                 , atoms.shift)
+
+  end
+
+  def test_reach
+    assert_equal(false, @cell00.reach?)
+    assert_equal([]  , @cell00.from_edges)
+    @cell00.reach(nil)
+    assert_equal(true, @cell00.reach?)
+    assert_equal([nil], @cell00.from_edges)
+
+    setup
+    edge = Crysna::TransitionFinder::Edge.new([0,1], 0.0, "")
+    @cell00.reach(edge)
+    assert_equal(true, @cell00.reach?)
+    assert_equal([edge], @cell00.from_edges)
+  end
+
+  def test_periodically_equal?
+    assert_equal(false, @cell00.periodically_equal?(@cell01))
+    assert_equal(false, @cell01.periodically_equal?(@cell00))
+    assert_equal(true , @cell00.periodically_equal?(@cell00))
+    assert_equal(true , @cell01.periodically_equal?(@cell01))
+
+    atoms = [
+      Crysna::Atom.new(0, "A", [1, 0, 0]),
+      Crysna::Atom.new(0, "B", [1, 1, 0]),
+      Crysna::Atom.new(1, "F", [1, 0, 0]),
+    ]
+    tfc02 = Crysna::TransitionFinder::Cell.new({}, -11.0)
+    tfc02.atoms = atoms
+    assert_equal(true , @cell01.periodically_equal?(tfc02))
+
+  end
+
+  #def test_reset
+  #    edge = Crysna::TransitionFinder::Edge.new([0,1], 0.0, "")
+  #    @cell00.from_edges = [edge]
+  #    @cell00.reach_flag = true
+  #    assert_equal(true , @cell00.reach_flag)
+  #    assert_equal([edge], @cell00.from_edges)
+  #    @cell00.reset
+  #    assert_equal(false , @cell00.reach_flag)
+  #    assert_equal([], @cell00.from_edges)
+  #end
+
+  def test_occupied_sitename
+    assert_equal('A555-B555-E555', @cell00.occupied_sitename)
+    assert_equal('A655-B655-F655', @cell01.occupied_sitename)
+    assert_equal('A655-B655-F655', @cell02.occupied_sitename)
+  end
+
+  def test_inspect_short
+    assert_equal('Crysna::TransitionFinder::Cell: A555-B555-E555, @energy = -10.0, @reach_flag = false, @from_edges = [], @name = ""', @cell00.inspect_short)
+    assert_equal('Crysna::TransitionFinder::Cell: A655-B655-F655, @energy = -11.0, @reach_flag = false, @from_edges = [], @name = ""', @cell01.inspect_short)
+    assert_equal('Crysna::TransitionFinder::Cell: A655-B655-F655, @energy = -11.0, @reach_flag = false, @from_edges = [], @name = "abc"', @cell02.inspect_short)
+  end
+
+  def test_operate
+    rotation0 = [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ]
+    rotation1 = [
+      [-1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ]
+    operations = [
+      {
+        "A" => ["A", [ 0, 0, 0], rotation0],
+        "B" => ["B", [ 0, 0, 0], rotation0],
+        "C" => ["C", [ 0, 0, 0], rotation0],
+        "D" => ["D", [ 0, 0, 0], rotation0],
+        "E" => ["E", [ 0, 0, 0], rotation0],
+        "F" => ["F", [ 0, 0, 0], rotation0],
+        "G" => ["G", [ 0, 0, 0], rotation0],
+      },
+      {
+        "A" => ["D", [ 0, 0, 0], rotation1],
+        "B" => ["C", [ 0, 0, 0], rotation1],
+        "C" => ["B", [ 0, 0, 0], rotation1],
+        "D" => ["A", [ 0, 0, 0], rotation1],
+        "E" => ["G", [ 0, 0, 0], rotation1],
+        "F" => ["F", [ 0, 0, 0], rotation1],
+        "G" => ["E", [ 0, 0, 0], rotation1],
+      }
+    ]
+    cell0 = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell0.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "B", [0, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    cell1 = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell1.atoms = [
+      Crysna::Atom.new(0, "C", [0, 0, 0]),
+      Crysna::Atom.new(0, "D", [0, 0, 0]),
+      Crysna::Atom.new(1, "G", [0, 0, 0]),
+    ]
+    assert_equal(cell0, cell0.operate(operations[0]))
+    assert_equal(cell1, cell0.operate(operations[1]))
+    assert_equal(cell1, cell1.operate(operations[0]))
+    assert_equal(cell0, cell1.operate(operations[1]))
+
+
+    cell0 = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell0.atoms = [
+      Crysna::Atom.new(0, "A", [1, 0, 0]),
+      Crysna::Atom.new(0, "B", [1, 0, 0]),
+      Crysna::Atom.new(1, "E", [1, 0, 0]),
+    ]
+    cell1 = Crysna::TransitionFinder::Cell.new({}, -10.0)
+    cell1.atoms = [
+      Crysna::Atom.new(0, "C", [-1, 0, 0]),
+      Crysna::Atom.new(0, "D", [-1, 0, 0]),
+      Crysna::Atom.new(1, "G", [-1, 0, 0]),
+    ]
+    assert_equal(cell0, cell0.operate(operations[0]))
+    assert_equal(cell1, cell0.operate(operations[1]))
+    assert_equal(cell1, cell1.operate(operations[0]))
+    assert_equal(cell0, cell1.operate(operations[1]))
+  end
+
+end
+

data/test/transitionfinder/test_cellmanager.rb

@@ -0,0 +1,185 @@
+#! /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::CellManager
+  attr_accessor :cells
+end
+
+class TC_CellManager < Test::Unit::TestCase
+
+  def setup
+    ##Cell
+    @cell_ABE = Crysna::TransitionFinder::Cell.new({0 => ["A", "B"], 1 => ["E"]}, -10.0)
+    @cell_ABEr = Marshal.load(Marshal.dump(@cell_ABE))
+    @cell_ABEr.reach_flag = true
+
+    @cell_ACE = Crysna::TransitionFinder::Cell.new({0 => ["A", "C"], 1 => ["E"]}, -10.0)
+    @cell_ACEr = Marshal.load(Marshal.dump(@cell_ACE))
+    @cell_ACEr.reach_flag = true
+
+    @cell_ABEp = Crysna::TransitionFinder::Cell.new({}, -12.0)
+    @cell_ABEp.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "B", [1, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    @cell_ABEpr = Marshal.load(Marshal.dump(@cell_ABEp))
+    @cell_ABEpr.reach_flag = true
+
+    @cell_ACpE = Crysna::TransitionFinder::Cell.new({}, -12.0)
+    @cell_ACpE.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "C", [1, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    @cell_ACpEr = Marshal.load(Marshal.dump(@cell_ACpE))
+    @cell_ACpEr.reach_flag = true
+
+    @cell_ADpE = Crysna::TransitionFinder::Cell.new({}, -12.0)
+    @cell_ADpE.atoms = [
+      Crysna::Atom.new(0, "A", [0, 0, 0]),
+      Crysna::Atom.new(0, "D", [1, 0, 0]),
+      Crysna::Atom.new(1, "E", [0, 0, 0]),
+    ]
+    @cell_ADpEr = Marshal.load(Marshal.dump(@cell_ADpE))
+    @cell_ADpEr.reach_flag = true
+
+    @cell_ACmE = Crysna::TransitionFinder::Cell.new({}, -12.0)
+    @cell_ACmE.atoms = [
+      Crysna::Atom.new(0, "A", [ 0, 0, 0]),
+      Crysna::Atom.new(0, "C", [-1, 0, 0]),
+      Crysna::Atom.new(1, "E", [ 0, 0, 0]),
+    ]
+    @cell_ACmEr = Marshal.load(Marshal.dump(@cell_ACmE))
+    @cell_ACmEr.reach_flag = true
+
+    ##CellManager
+    @cm00 = Crysna::TransitionFinder::CellManager.new
+
+    @cm01 = Crysna::TransitionFinder::CellManager.new
+    @cm01.cells = [
+      @cell_ABE,
+      @cell_ACE,
+    ]
+
+    @cm02 = Crysna::TransitionFinder::CellManager.new
+    @cm02.cells = [
+      @cell_ABE,
+      @cell_ACE,
+      @cell_ABEp,
+      @cell_ACpE,
+      @cell_ADpE,
+      @cell_ACmE,
+    ]
+
+    @cm03 = Crysna::TransitionFinder::CellManager.new
+    @cm03.cells = [
+      @cell_ABEr,
+      @cell_ACEr,
+      @cell_ABEpr,
+      @cell_ACpEr,
+      @cell_ADpEr,
+      @cell_ACmE,
+    ]
+  end
+
+  def test_add
+    result = @cm00.add(@cell_ABE)
+    assert_equal(0, result)
+    assert_equal(@cell_ABE, @cm00.cells[0])
+    assert_equal(1, @cm00.cells.size)
+
+    #already added
+    result = @cm00.add(@cell_ABE)
+    assert_equal(0, result)
+    assert_equal(@cell_ABE, @cm00.cells[0])
+    assert_equal(1, @cm00.cells.size)
+
+    #new
+    result = @cm00.add(@cell_ACE)
+    assert_equal(1, result)
+    assert_equal(@cell_ABE, @cm00.cells[0])
+    assert_equal(@cell_ACE, @cm00.cells[1])
+    assert_equal(2, @cm00.cells.size)
+  end
+
+  def test_fetch
+    assert_equal(nil, @cm00[0])
+    assert_equal(@cell_ABE, @cm01[0])
+  end
+
+  def test_index_same_atoms
+    assert_equal(0, @cm01.index_same_atoms(@cell_ABE))
+    assert_equal(1, @cm01.index_same_atoms(@cell_ACE))
+    assert_equal(nil, @cm01.index_same_atoms(@cell_ABEp))
+  end
+
+  def test_index_same_sites
+    assert_equal(0, @cm01.index_same_sites(@cell_ABE))
+    assert_equal(1, @cm01.index_same_sites(@cell_ACE))
+
+    #pp @cm01
+    #pp @cell_ABEp
+    assert_equal(0, @cm01.index_same_sites(@cell_ABEp))
+  end
+
+  def test_reach
+    #pp @cm01
+    assert_equal(false, @cm01.cells[0].reach?)
+    assert_equal(false, @cm01.cells[1].reach?)
+    assert_equal([],     @cm01.cells[1].from_edges)
+    edge = Crysna::TransitionFinder::Edge.new([0,1], 0.0, "")
+    @cm01.reach(1, edge)
+    assert_equal(false, @cm01.cells[0].reach?)
+    assert_equal(true , @cm01.cells[1].reach?)
+    assert_equal([edge],     @cm01.cells[1].from_edges)
+  end
+
+  def test_periodically_shift_indices
+    assert_equal([], @cm00.periodically_shift_indices)
+
+    assert_equal([], @cm01.periodically_shift_indices)
+
+    results = @cm02.periodically_shift_indices
+    assert_equal( [], results
+    )
+
+    results = @cm03.periodically_shift_indices
+    assert_equal( [ [0, 2], [1, 3], [4]], results
+    )
+  end
+
+  def test_contain_periodically_shift_cell?
+    assert_equal(false, @cm00.contain_periodically_shift_cells?)
+    assert_equal(false, @cm01.contain_periodically_shift_cells?)
+    assert_equal(false, @cm02.contain_periodically_shift_cells?)
+    assert_equal(true , @cm03.contain_periodically_shift_cells?)
+  end
+
+  def test_ascend
+    @cm02.reach(0, nil)
+    edge = Crysna::TransitionFinder::Edge.new([0,2], 0.0, "")
+    @cm02.reach(2, edge)
+    edge = Crysna::TransitionFinder::Edge.new([2,1], 0.0, "")
+    @cm02.reach(1, edge)
+    assert_equal([1,2,0], @cm02.ascend(1))
+  end
+
+  #def test_to_s
+  #    #assert_equal("Crysna::TransitionFinder::CellManager: [ABE000000000, @energy = -10.0, @reach_flag = false, @previous_cell = ACE000000000, @energy = -10.0, @reach_flag = false, @previous_cell = ]", @cm01.to_s)
+  #    #"ABE000000000
+  #    #@cm01.add(@cell_ABE)
+  #    #@cm01.add(@cell_ACE)
+  #end
+
+end
+