crysna 0.0.4

data/lib/crysna/transitionfinder/cell.rb

@@ -0,0 +1,144 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+class Crysna::TransitionFinder::Cell < Crysna::Cell
+
+  #@from_edges of a start cell must be set to be []
+  attr_reader     :from_edges
+  attr_reader     :reach_flag
+  attr_reader     :atoms
+  attr_accessor :name
+  attr_accessor :energy
+
+  class RangeError < Exception; end
+
+  def initialize(sites, energy = nil, name = "")
+    super(sites)
+    @energy = energy
+    @reach_flag = false
+    @from_edges = [] # include Edge.
+    @name = name
+  end
+
+  def ==(other)
+    result = true
+    result = false if @atoms            != other.atoms
+    result = false if @energy           != other.energy
+    result = false if @reach_flag != other.reach_flag
+    result = false if @from_edges != other.from_edges
+    result = false if @name             != other.name
+    return result
+  end
+
+  def same_atoms?(other)
+    return @atoms == other.atoms
+  end
+
+  def same_sites?(other)
+    result = true
+    @atoms.size.times do |index|
+      if @atoms[index].site.name != other.atoms[index].site.name
+        result = false
+        break
+      end
+    end
+    return result
+  end
+
+  #Migrate atom of index to site and in the cell
+  #which is neighboring with the direction of global_vector.
+  #Generating new cell which is not reached.
+  #This method does not raise error even when destination site
+  #is already occupied,
+  #then, there are two atoms in the site.
+  def migrate!(index, site, global_vector, io = File.open(File::NULL, "w"))
+    io.puts "##{self.class}.migrate!(#{index}, #{site}, #{global_vector}"
+    raise RangeError if index >= atoms.size
+
+    atoms #sort
+    @atoms[index].migrate!(site, global_vector)
+    io.puts "Atoms after migration:"
+    @atoms.each do |atom|
+      io.puts "#{atom.element}, #{atom.site.name}, #{atom.site.global_vector}"
+    end
+
+    @atoms.sort!
+    io.puts "Atoms after sort:"
+    @atoms.each do |atom|
+      io.puts "#{atom.element}, #{atom.site.name}, #{atom.site.global_vector}"
+    end
+    reset
+  end
+
+  #Not-destructive method of migrate!()
+  def migrate(index, site, global_vector)
+    result = Marshal.load(Marshal.dump(self))
+    result.migrate!(index, site, global_vector)
+    result
+  end
+
+  #Set reach flag to be true.
+  #'edge' is the one between cells of already reached cell and self.
+  def reach(edge)
+    @reach_flag = true
+    @from_edges << edge
+  end
+
+  #Return true if already reached.
+  def reach?
+    return @reach_flag
+  end
+
+  #Return true if all sites correspond to those of the other.
+  #It is ok even if global vector is different.
+  def periodically_equal?(other)
+    self.atoms.sort.map{|atom| atom.site.name} == other.atoms.sort.map{|atom| atom.site.name}
+  end
+
+  def occupied_sitename
+    result = ''
+    result += atoms.map do |atom|
+      periodic_num = ''
+      atom.site.global_vector.each do |i|
+        periodic_num += (i + 5).to_s
+      end
+      atom.site.name + periodic_num
+    end . join "-"
+    result
+  end
+
+  def inspect_short
+    result = "#{self.class}: "
+    result += occupied_sitename
+    #result += '-'
+    result += ", @energy = #{@energy}"
+    result += ", @reach_flag = #{@reach_flag}"
+    result += ", @from_edges = #{@from_edges}"
+    result += ", @name = \"#{@name}\""
+    return result
+  end
+
+  #def inspect
+  #    result = 
+  #    to_s
+  #end
+  #
+  
+  def operate(operation)
+    result = super(operation)
+    result.energy = @energy
+    return result
+  end
+
+  private
+
+  #Reset information of reach and edge.
+  #(@reach_flag and @from_edges)
+  def reset
+    @reach_flag = false
+    @from_edges = []
+    @name = nil
+  end
+
+end
+

data/lib/crysna/transitionfinder/cellmanager.rb

@@ -0,0 +1,129 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+#
+#
+class Crysna::TransitionFinder::CellManager
+
+  attr_reader :cells
+
+  #
+  def initialize
+    @cells = []
+  end
+
+  #Add entry of cell as node.
+  #Return index of the name.
+  #If the cell is already added, do nothing and return the same cell.
+  def add(cell)
+    #index = @cells.find {|tgt_cell| cell == tgt_cell}
+    index = index_same_atoms cell
+    if index
+      return index
+    else
+      @cells << cell
+      return @cells.size - 1
+    end
+  end
+
+  #Return a cell of index.
+  def [](nth)
+    @cells[nth]
+  end
+
+  #Return index of the cell in CellManager instance.
+  def index_same_atoms(cell)
+    #@cells.index(cell)
+
+    result = nil
+    @cells.each_with_index do |tmp_cell, id|
+      if cell.same_atoms?(tmp_cell)
+        result = id
+        break
+      end
+    end
+    return result
+  end
+
+  #Return index of the cell with the same site in CellManager instance.
+  def index_same_sites(cell)
+    result = nil
+    @cells.each_with_index do |tmp_cell, id|
+      if cell.same_sites?(tmp_cell)
+        result = id
+        break
+      end
+    end
+    return result
+  end
+
+  #Set reach flag to the cell of 'dst_cell_index'.
+  #'edge' is added into '@from_edges' of the cell.
+  #'nil' data is available for 'edge'. (E.g., starting cell.)
+  def reach(dest_cell_index, edge)
+    @cells[dest_cell_index].reach(edge)
+  end
+
+
+  #Return a two-dimensional array,
+  #whose items are indices of the cells of groups of identical nodes
+  #among reached cells.
+  def periodically_shift_indices
+    results = []
+    @cells.each_with_index do |cell, c_index|
+      next unless cell.reach?
+      entering_index = results.size
+      results.each_with_index do |group, g_index|
+        if @cells[group[0]].periodically_equal? cell
+          entering_index = g_index
+          break
+        end
+      end
+      results[entering_index] ||= []
+      results[entering_index] << c_index
+    end
+    return results
+  end
+
+  def contain_periodically_shift_cells?
+    if periodically_shift_indices.find {|i| i.size > 1}
+      return true
+    else
+      return false # nil is converted to false.
+    end
+  end
+
+  #Return an array of indices from a cell of 'index' in @cells
+  #to the origin cell.
+  #The origin cell is the cell whose @from_edges has nil
+  #at the first item.
+  #Note that this method uses only the first item in @flom_edges
+  #of cells.
+  def ascend(index)
+    results = []
+    while true
+      results << index
+      edge = @cells[index].from_edges[0]
+      #pp edge
+      break unless edge
+      index = edge.nodes[0]
+    end
+
+    #current_index = last_index
+    #while current_index != nil
+    #    results << current_index
+    #    current_index = @cells[current_index].previous_cell
+    #end
+    return results
+  end
+
+  #def to_s
+  #    result = "["
+  #    tmp = @cells.map { |cell| result += cell.to_s }.join(", ")
+  #    result += "]"
+  #    return result
+  #end
+
+end
+

data/lib/crysna/transitionfinder/edge.rb

@@ -0,0 +1,54 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+class Crysna::TransitionFinder::Edge
+
+  #attr_reader :nodes, :atom_id, :to_site, :global_vector, :operation, :weight
+  attr_reader :nodes, :weight, :note
+
+  class InitializeError < Exception; end
+
+  #'nodes' is assumed to be an array of 2 items which have indices of cells.
+  # E.g., [0, 3]
+  #'migration' indicates an array of 2 items which have source and destination sites
+  #as String. E.g., ["A", "C"]
+  #'operation' indicates an index of symmetry_operations in model.yaml.
+  #'weight' indicates a weight of the edge.
+  #def initialize(nodes, atom_id, to_site, global_vector, operation, weight)
+  def initialize(nodes, weight, note)
+    if nodes.size != 2
+      raise InitializeError, nodes.to_s
+    end
+    @nodes = nodes
+    #@atom_id = atom_id
+    #@to_site = to_site
+    #@global_vector = global_vector
+    #@operation = operation
+    @weight = weight
+    @note = note
+  end
+
+  #Return true if @nodes, @migrations, @operation, @weight are the same as others',
+  #respectively.
+  #Inverse edge will return false. E.g., 
+  #e00 = Crysna::TransitionFinder::Edge.new([0, 1], ["A", "B"], 0, -1.0)
+  #e01 = Crysna::TransitionFinder::Edge.new([1, 0], ["B", "A"], 0, -1.0)
+  #e00 == e01 #=> false
+  def ==(other)
+    result = true
+    result = false if @nodes         != other.nodes
+    #result = false if @atom_id != other.atom_id
+    #result = false if @to_site != other.to_site
+    #result = false if @global_vector != other.global_vector
+    #result = false if @operation != other.operation
+    result = false if @weight        != other.weight
+    result = false if @note      != other.note
+    return result
+  end
+
+  #def to_s_short
+  #    #"cell:#{@nodes[0]}->#{@nodes[1]}(mig:#{@migration[0]}->#{@migration[1]}, ope:#{@operation}, wgt:#{@weight})"
+  #end
+
+end
+

data/test/.gitignore

@@ -0,0 +1 @@
+*.out

data/test/cell_orig/POSCAR

@@ -0,0 +1,17 @@
+Model to test optimizeframe command
+1.0
+  2.0  2.0  2.0
+  0.0  2.0  2.0
+  0.0  0.0  2.0
+7 1 2
+Direct
+  0.10  0.10  0.10
+  0.10  0.10  0.11
+  0.10  0.10  0.13
+  0.10  0.12  0.10
+  0.10  0.16  0.10
+  0.13  0.10  0.10
+  0.19  0.10  0.10
+  0.11  0.11  0.11
+  0.00  0.00  0.00
+  0.90  0.90  0.90

data/test/cell_orig/model.yaml

@@ -0,0 +1,122 @@
+---
+frame_elements:
+- 0
+frame_sites:
+  FS_000:
+  - 0.0
+  - 0.0
+  - 0.0
+  FS_001:
+  - 0.0
+  - 0.0
+  - 0.01
+  FS_003:
+  - 0.0
+  - 0.0
+  - 0.03
+  FS_020:
+  - 0.0
+  - 0.02
+  - 0.0
+  FS_060:
+  - 0.0
+  - 0.06
+  - 0.0
+  FS_300:
+  - 0.03
+  - 0.0
+  - 0.0
+  FS_900:
+  - 0.09
+  - 0.0
+  - 0.0
+symmetry_operations:
+- rotation:
+  - - 1
+    - 0
+    - 0
+  - - 0
+    - 1
+    - 0
+  - - 0
+    - 0
+    - 1
+  translation:
+  - 0.0
+  - 0.0
+  - 0.0
+- rotation:
+  - - -1
+    - 0
+    - 0
+  - - 0
+    - -1
+    - 0
+  - - 0
+    - 0
+    - -1
+  translation:
+  - 0.0
+  - 0.0
+  - 0.0
+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