"""
結晶空間群に関するデータと操作を提供するモジュール。
詳細説明:
このモジュールは、空間群の名称、指標、対称操作、格子系などの情報を扱い、
SPGDB (Space Group Database) からの読み込みや解析を行うためのクラス `tkSpaceGroup` を提供します。
結晶構造データの解析やシミュレーションにおいて、空間群の情報を正確に管理するために使用されます。
関連リンク:
:doc:`tkspacegroup_usage`
"""
import sys
import os
import numpy as np
from numpy import sin, cos, tan, pi
import csv
from pprint import pprint
from tklib.tkprogvars import ProgramDir, DBDir, AtomDBDir, RietanDir
from tklib.tkfile import tkFile
from tklib.tksci.tksci import a0, torad, todeg, Round, Reduce01
from tklib.tkutils import SplitFilePath, GetList, pint, pfloat
from tklib.tkre import DelQuote, DelSpace
import tklib.tkre as tkre
from tklib.tkcrystal.tkspacegroupobject import tkSpaceGroupObject
#DBDir = os.path.join(ProgramDir, 'Databases')
RietanProgramPath = os.path.join(RietanDir, "RIETAN_VENUS")
RietanPath = os.path.join(RietanProgramPath, "RIETAN64.exe")
#SPGDBPath = os.path.join(RietanDir, "RIETAN_VENUS", "SPGRA")
#SPGRDBPath = os.path.join(RietanDir, "RIETAN_VENUS", "spgr.daf")
#ASFDCPath = os.path.join(RietanDir, "RIETAN_VENUS", "asfdc")
SPGDBPath = os.path.join(DBDir, "spgra")
SPGRDBPath = os.path.join(DBDir, "Spgr.daf")
ASFDCPath = os.path.join(DBDir, "asfdc")
AtomsDBDir = os.path.join(DBDir, "atoms")
#print("SPGDBPath=", SPGDBPath)
#=====================================
# Space group class
#=====================================
[ドキュメント]
class tkSpaceGroup(tkSpaceGroupObject):
"""
空間群のデータを管理し、関連する操作を提供するクラス。
詳細説明:
tkSpaceGroupObjectを継承し、空間群の名称、指標、対称操作、格子パラメータ、格子系などを保持・操作します。
SPGDBファイルから空間群情報を読み込み、結晶学的な解析をサポートします。
"""
def __init__(self, **args):
"""
tkSpaceGroupオブジェクトを初期化する。
詳細説明:
親クラスの初期化に加え、格子パラメータ、空間群名、格子系、格子軸などの内部変数を設定します。
:param args: 初期設定のためのキーワード引数。
"""
super(tkSpaceGroup, self).__init__(**args)
self.__Latt = [0.0]*6 #np.empty(6)
self.__SPGName = ''
self.__LatticeSystem = None
self.__LatticeAxis = None
self.update(**args)
def __del__(self):
"""
tkSpaceGroupオブジェクトを削除する。
詳細説明:
親クラスのデストラクタを呼び出します。
"""
super(tkSpaceGroup, self).__del__()
def __str__(self):
"""
オブジェクトの文字列表現を返す。
詳細説明:
このオブジェクトのクラスパスを返します。
:returns: str: オブジェクトのクラスパス。
"""
return self.ClassPath()
[ドキュメント]
def SetP1(self):
"""
空間群をP1 (三斜晶系、空間群番号1) に設定する。
詳細説明:
対称操作をクリアし、空間群名、空間群番号、セット番号をP1に設定します。
基本的な対称操作として 'x,y,z' を追加し、格子系と格子軸を 'triclinic' に設定します。
"""
self.ClearSymmetryOperation();
self.SetSPGName("P 1");
self.SetiSPG(1);
self.SetiSet(1);
# self.AnalyzeTranslation();
self.AddSymmetryOperation('x,y,z');
self.SetLatticeSystem(latticesystem = 'triclinic');
self.SetLatticeAxis(latticeaxis = 'triclinic');
[ドキュメント]
def SetSPGName(self, SPGName):
"""
空間群名称を設定する。
詳細説明:
与えられた名称から引用符を除去して設定します。
:param SPGName: str: 設定する空間群名称。
"""
self.__SPGName = tkre.DelQuote(SPGName)
[ドキュメント]
def SPGName(self):
"""
設定されている空間群名称を返す。
:returns: str: 空間群名称。
"""
return self.__SPGName
[ドキュメント]
def SetiSPG(self, iSPG):
"""
空間群番号を設定する。
詳細説明:
与えられた値を整数型に変換して設定します。
:param iSPG: int: 設定する空間群番号。
"""
self.__iSPG = pint(iSPG, 0)
[ドキュメント]
def iSPG(self):
"""
設定されている空間群番号を返す。
:returns: int: 空間群番号。
"""
return self.__iSPG
[ドキュメント]
def SetiSet(self, iSet = 1):
"""
セット番号を設定する。
詳細説明:
与えられた値を整数型に変換して設定します。デフォルト値は1です。
:param iSet: int: 設定するセット番号。デフォルトは1。
"""
self.__iSet = pint(iSet, 1)
[ドキュメント]
def iSet(self):
"""
設定されているセット番号を返す。
:returns: int: セット番号。
"""
return self.__iSet
[ドキュメント]
def SetSpaceGroup(self, SPGName, iSPG, iSet = 1):
"""
空間群の名称、空間群番号、セット番号をまとめて設定する。
詳細説明:
与えられた名称から引用符を除去し、番号を整数型に変換して設定します。
:param SPGName: str: 設定する空間群名称。
:param iSPG: int: 設定する空間群番号。
:param iSet: int: 設定するセット番号。デフォルトは1。
"""
self.__SPGName = tkre.DelQuote(SPGName)
self.__iSPG = pint(iSPG, 0)
self.__iSet = pint(iSet, 1)
[ドキュメント]
def iLaueG(self):
"""
設定されているLaue群のインデックスを返す。
詳細説明:
内部変数 `__iLaueG` の値を返します。
:returns: int: Laue群のインデックス。
"""
return self.__iLaueG
[ドキュメント]
def iCenter(self):
"""
中心化の数を返す。
詳細説明:
内部変数 `__iCenter` の値を返します。
"""
return self.__iCenter
[ドキュメント]
def LaueGroupByRietanIndex(self, idx = None):
"""
RIETANのLaue群インデックスに基づいてLaue群名称を返す。
詳細説明:
1から15までのインデックスに対応するLaue群の名称をリストから取得します。
:param idx: int, optional: Laue群のインデックス (1-15)。デフォルトはNone。
:returns: str: 対応するLaue群の名称。インデックスが無効な場合は空文字列。
"""
if idx is None or idx < 1 or idx > 15:
return ''
LaueGroup = [
"Triclinic (1)", # 1 \
"Monoclinic, a (2/m)", # 2 \
"Monoclinic, b (2/m)", # 3 \
"Monoclinic, c (2/m)", # 4 \
"Orthorhombic (mmm)", # 5 \
"Tetragonal (4/m)", # 6 \
"Tetragonal (4/mmm)", # 7 \
"Trigonal, Rhombohedral (3)", # 8 \
"Trigonal, Hexagonal (3)", # 9 \
"Trigonal, Rhombohedral (3m)", # 10 \
"Trigonal, Hexagonal (3m)", # 11 \
"Hexagonal (6/m)", # 12 \
"Hexagonal (6/mmm)", # 13 \
"Cubic (m3)", # 14 \
"Cubic (m3m)" # 15 \
]
return LaueGroup[idx-1]
[ドキュメント]
def LatticeSystemFromLaueGroup(self, LaueG):
"""
Laue群の名称から格子系を推測し、返す。
詳細説明:
特定のLaue群名に基づいて格子系（例えば、菱面体晶、三方晶、単斜晶など）を判断します。
Laue群名の括弧内の情報は除去されます。
:param LaueG: str: Laue群の名称。
:returns: str: 推測された格子系の名称 (小文字)。
"""
if LaueG == "Trigonal, Rhombohedral (3)":
return 'rhombohedral'
if LaueG == "Trigonal, Hexagonal (3)":
return 'trigonal'
if LaueG == "Trigonal, Rhombohedral (3m)":
return 'rhombohedral'
if LaueG == "Trigonal, Hexagonal (3m)":
return 'trigonal'
LatticeSystem = DelSpace(LaueG)
LatticeSystem = tkre.Sub(r'\s*\([^\s,]+\)', '', LatticeSystem)
return LatticeSystem.lower()
[ドキュメント]
def ReadSpaceGroupFromSPGName(self, SPGName):
"""
空間群名称に基づいて空間群データを読み込む。
詳細説明:
空間群名称から空間群番号とセット番号を特定し、その情報を用いて `ReadSpaceGroup` メソッドを呼び出します。
:param SPGName: str: 検索する空間群名称。
:returns: dict or None: 読み込まれた空間群データを含む辞書、または見つからない場合はNone。
"""
SPGName1 = tkre.Sub(r'\s+', '', SPGName)
count, iSPG, iSet = self.GetiSPGFromSPGName(SPGName)
return self.ReadSpaceGroup(iSPG, iSet)
[ドキュメント]
def ReadNextSpaceGroup(self, db):
"""
データベースファイルから次の空間群エントリを読み込む。
詳細説明:
指定されたデータベースオブジェクトから1つの空間群エントリをパースし、辞書形式で返します。
読み込みはファイルの現在の位置から行われます。
:param db: tklib.tkfile.tkFile: 空間群データベースファイルオブジェクト。
:returns: dict or None: 読み込まれた空間群データを含む辞書、またはファイルの終端に達した場合や無効なエントリの場合はNone。
"""
line = db.ReadLine()
if not line or tkre.Match('---', line):
return None
list = tkre.Search(r'(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S.*)\s*$', line)
if list[6] is None:
return None
self.dprint(1, list)
iSPG = int(list[1])
iSet = int(list[2])
iLaueG = int(list[3])
nCenter = int(list[4])
nSym = int(list[5])
SPGName = list[6]
LaueG = self.LaueGroupByRietanIndex(iLaueG)
ICONDLine = db.ReadLine()
ICOND = tkre.Search("^(.{2})(.{2})(.{2})(.{2})(.{2})(.{2})(.{2})"
+"(.{2})(.{2})(.{2})(.{2})(.{2})(.{2})(.{2})", ICONDLine)
RCond = []
for i in range(len(ICOND)-1):
RCond.append(int(ICOND[i+1]))
SymOp = []
for i in range(nSym):
op = db.ReadLine()
SymOp.append(DelQuote(op))
spg = {
'SPGName': SPGName,
'iSPG' : iSPG,
'iSet' : iSet,
'iLaueG' : iLaueG,
'LaueG' : LaueG,
'LatticeSystem': self.LatticeSystemFromLaueGroup(LaueG),
# 'LatticeAxis' : self.AnalyzeLatticeAxis(),
'nCenter': nCenter,
'nSym' : nSym,
'SymOp' : SymOp,
'RCond' : RCond
}
return spg
[ドキュメント]
def ReadSpaceGroup(self, ispg, iset, SettoSelf = 0, dbpath = SPGDBPath, StopByError = 1):
"""
空間群番号とセット番号に基づいて空間群データをデータベースから読み込む。
詳細説明:
指定された空間群番号とセット番号に合致するエントリをデータベースから探し、そのデータを返します。
読み込んだデータをオブジェクト自身に設定することもできます。
:param ispg: int: 検索する空間群番号。
:param iset: int: 検索するセット番号。
:param SettoSelf: int, optional: 読み込んだデータをこのオブジェクト自身に設定するかどうかのフラグ (0:しない, 1:する)。デフォルトは0。
:param dbpath: str, optional: 空間群データベースファイルのパス。デフォルトは `SPGDBPath`。
:param StopByError: int, optional: エラー時にプログラムを終了するかどうかのフラグ (0:しない, 1:する)。デフォルトは1。
:returns: dict or None: 読み込まれた空間群データを含む辞書 (SettoSelf=0の場合)、または None (見つからない場合やエラー時)。
SettoSelf=1の場合は、このオブジェクト自体にデータが設定され、戻り値は None。
"""
# print "SPGDBPath: $SpaceGroupDBPath\n" if($IsPrint);
if ispg == 0:
return None
db = tkFile(dbpath, 'r', OpenFile = True)
if not db.fp:
print("Error in tkcrystal.tkspacegroup.ReadSpaceGroup: "
+ "Can not read from [{}].".format(dbpath))
if StopByError:
exit()
return 0
while 1:
spg = self.ReadNextSpaceGroup(db)
if not spg:
db.Close()
print("Error in tkcrystal.tkspacegroup.ReadSpaceGroup: "
+ "Can not find SPG for [{}.{}] from [{}].".format(ispg, iset, dbpath))
if StopByError:
exit()
return None
if spg["iSPG"] == ispg and spg["iSet"] == iset:
db.Close()
if SettoSelf:
self.SetSPGName(spg["SPGName"])
self.SetiSPG(spg["iSPG"])
self.SetiSet(spg["iSet"])
self.SetiLaueGroup(spg["iLaueG"])
# self.AnalyzeTranslation()
# self.ExpandSymmetryOperation($nCentr);
else:
SPG = tkSpaceGroup()
SPG.SetSPGName(spg["SPGName"])
SPG.SetiSPG(spg["iSPG"])
SPG.SetiSet(spg["iSet"])
SPG.SetiLaueGroup(spg["iLaueG"])
# SPG.AnalyzeTranslation()
# SPG.ExpandSymmetryOperation($nCentr);
spg["SPG"] = SPG
return spg
[ドキュメント]
def GetSpaceGroupList(self, dbpath = SPGDBPath, StopByError = 1):
"""
空間群データベースからすべての空間群のリストを取得する。
詳細説明:
データベースを読み込み、各空間群エントリのSPG番号、セット番号、名称を含む文字列のリストを生成します。
:param dbpath: str, optional: 空間群データベースファイルのパス。デフォルトは `SPGDBPath`。
:param StopByError: int, optional: エラー時にプログラムを終了するかどうかのフラグ (0:しない, 1:する)。デフォルトは1。
:returns: list[str] or int: 空間群の情報を整形した文字列のリスト、またはエラー時に0。
"""
db = tkFile(dbpath, 'r')
if not db:
db.Close()
print("Error in tkcrystal.tkrietan.GetSpaceGroupList: "
+ "Can not read from [{}].".format(dbpath))
if StopByError:
exit()
return 0
spglist = []
count = 0
while 1:
spg = self.ReadNextSpaceGroup(db)
if not spg:
break
count += 1
str = "%3d-%d (%s) [%d]" % (spg["iSPG"], spg["iSet"], spg["SPGName"], count)
spglist.append(str)
db.Close()
return spglist
[ドキュメント]
def GetiSPGFromSPGName(self, spgname, dbpath = SPGDBPath, StopByError = 1):
"""
空間群名称から空間群番号とセット番号を取得する。
詳細説明:
データベースを検索し、指定された空間群名称に一致するエントリの空間群番号、セット番号、
およびデータベース内のインデックス（カウント）を返します。
:param spgname: str: 検索する空間群名称。
:param dbpath: str, optional: 空間群データベースファイルのパス。デフォルトは `SPGDBPath`。
:param StopByError: int, optional: エラー時にプログラムを終了するかどうかのフラグ (0:しない, 1:する)。デフォルトは1。
:returns: tuple[int, int, int] or int: (カウント, 空間群番号, セット番号) のタプル。見つからない場合は (-1, -1, -1)。エラー時に0。
"""
db = tkFile(dbpath, 'r')
if not db:
db.Close()
print("Error in tkcrystal.tkrietan.GetiSPGFromSPGName: "
+ "Can not read from [{}].".format(dbpath))
if StopByError:
exit()
return 0
spgname1 = tkre.Sub(r'\s+', '', spgname)
spglist = []
count = 0
while 1:
spg = self.ReadNextSpaceGroup(db)
if not spg:
break
count += 1
SPGName = tkre.Sub(r'\s+', '', spg["SPGName"])
if SPGName.upper() == spgname1.upper():
db.Close()
return count, spg["iSPG"], spg["iSet"]
db.Close()
print("Error in tkcrystal.tkrietan.GetiSPGFromSPGName: "
+ "Can not find SPG {} from [{}].".format(spgname, dbpath))
if StopByError:
exit()
return -1, -1, -1
[ドキュメント]
def ClearSymmetryOperation(self):
"""
設定されている対称操作と並進ベクトルをクリアする。
詳細説明:
対称操作リストを空にし、並進ベクトルを '[0, 0, 0]' のみを含む状態にリセットします。
これにより、対称操作と並進の数を更新します。
"""
self.__SymmetryOperation = []
self.__nSymmetryOperation = len(self.__SymmetryOperation)
self.__TranslationVector = []
self.__TranslationVector.append([0, 0, 0])
self.__nTranslation = len(self.__TranslationVector)
[ドキュメント]
def DoSymmetryOperation(self, iop, pos, IsReduce01 = 1):
"""
指定された対称操作を座標に適用する。
詳細説明:
指定されたインデックスの対称操作を、与えられた座標に適用し、新しい座標を計算します。
オプションで結果を0から1の範囲に正規化します。
:param iop: int: 適用する対称操作のインデックス。
:param pos: list[float]: 適用する元の座標 [x, y, z]。
:param IsReduce01: int, optional: 結果を0から1の範囲に正規化するかどうかのフラグ (1:正規化する, 0:しない)。デフォルトは1。
:returns: list[float] or None: 対称操作適用後の新しい座標 [x', y', z']。入力が無効な場合はNone。
"""
if pos is None:
return None
sym = tkre.Split(r'[\s,]+', self.SymmetryOperation(iop))
# print("sym=", sym)
x = pos[0]
y = pos[1]
z = pos[2]
if x is None or y is None or z is None:
return None
# print("sym=", sym, [x,y,z])
x1 = eval(sym[0])
y1 = eval(sym[1])
z1 = eval(sym[2])
if IsReduce01:
return [Reduce01(x1), Reduce01(y1), Reduce01(z1)]
else:
return [x1, y1, z1]
[ドキュメント]
def DoVelocitySymmetryOperation(self, iop, v, IsReduce01 = 0):
"""
指定された対称操作を速度ベクトルに適用する。
詳細説明:
速度ベクトルに対して `DoSymmetryOperation` メソッドを呼び出しますが、正規化は行いません。
これは、速度が周期境界条件を考慮しないためです。
:param iop: int: 適用する対称操作のインデックス。
:param v: list[float]: 適用する元の速度ベクトル [vx, vy, vz]。
:param IsReduce01: int, optional: 結果を0から1の範囲に正規化するかどうかのフラグ (0:しない)。常に0が渡されます。
:returns: list[float] or None: 対称操作適用後の新しい速度ベクトル [vx', vy', vz']。入力が無効な場合はNone。
"""
if v is None:
return None
return self.DoSymmetryOperation(iop, v, 0)
"""
sub DoSymmetryOperation
{
my ($this, $iop, $x, $y, $z, $IsReduce01) = @_;
my $nSymmetryOperation = $this->nSymmetryOperation();
my $iSymmetryOperation = $iop % $nSymmetryOperation;
my $iTranslateOperation = int($iop / $nSymmetryOperation);
my ($tx, $ty, $tz) = $this->TranslationVector($iTranslateOperation+1);
my $symop = $this->SymmetryOperation($iSymmetryOperation+1);
$symop = lc $symop;
$symop =~ s/([xyz])/\$$1/g;
my ($sx,$sy,$sz) = ($symop =~ /^(.*?),(.*?),(.*)$/);
#print "is=$iop: T=($tx, $ty, $tz), S=($sx, $sy, $sz)\n";
my $xs = eval($sx)+$tx;
my $ys = eval($sy)+$ty;
my $zs = eval($sz)+$tz;
if($IsReduce01) {
$xs = Utils::Reduce01(AtomSiteObject::Round01($xs));
$ys = Utils::Reduce01(AtomSiteObject::Round01($ys));
$zs = Utils::Reduce01(AtomSiteObject::Round01($zs));
}
return ($xs,$ys,$zs);
}
sub DoVelocitySymmetryOperation
{
my ($this, $iop, $vx, $vy, $vz) = @_;
return (0, 0, 0) if(not defined $vx);
my $nSymmetryOperation = $this->nSymmetryOperation();
my $iSymmetryOperation = $iop % $nSymmetryOperation;
my $symop = $this->SymmetryOperation($iSymmetryOperation+1);
my ($xo,$yo,$zo) = ($symop =~ /^(.*?),\s*(.*?),\s*(.*?)$/);
my ($x1,$y1,$z1,$t1) = &SymOpToMatrix($xo);
my ($x2,$y2,$z2,$t2) = &SymOpToMatrix($yo);
my ($x3,$y3,$z3,$t3) = &SymOpToMatrix($zo);
my $vxs = $x1*$vx + $y1*$vy + $z1*$vz;
my $vys = $x2*$vx + $y2*$vy + $z2*$vz;
my $vzs = $x3*$vx + $y3*$vy + $z3*$vz;
return ($vxs,$vys,$vzs);
}
"""
[ドキュメント]
def nSymmetryOperation(self):
"""
現在設定されている対称操作の数を返す。
:returns: int: 対称操作の数。
"""
self.__nSymmetryOperation = len(self.__SymmetryOperation)
return self.__nSymmetryOperation
[ドキュメント]
def nTranslation(self):
"""
現在設定されている並進ベクトルの数を返す。
:returns: int: 並進ベクトルの数。
"""
self.__nTranslation = len(self.__TranslationVector)
return self.__nTranslation
[ドキュメント]
def TranslationVector(self, i):
"""
指定されたインデックスの並進ベクトルを返す。
:param i: int: 取得する並進ベクトルのインデックス。
:returns: list[int]: 並進ベクトル [tx, ty, tz]。
"""
return self.__TranslationVector[i]
[ドキュメント]
def GuessBravaisLattice(self, tollatt, tolangle, EPSCoord):
"""
空間群名と格子パラメータに基づいてBravais格子を推測する。
詳細説明:
まず空間群名からF, I, A, B, Cなどの中心化情報をチェックします。
その後、原子サイト情報が存在する場合は、サイトの位置から中心化を判定します。
:param tollatt: float: 格子定数の許容誤差。
:param tolangle: float: 格子角の許容誤差。
:param EPSCoord: float: 座標の許容誤差。
:returns: list[str]: [格子系, Bravais格子タイプ] のリスト。
"""
latt = self.LatticeParameters()
SPGName = self.SPGName()
ls = self.LatticeSystem().lower()
if ls == '':
LatticeSystem = self.SetLatticeSystem(None, 1, tollatt, tolangle)
else:
LatticeSystem = ls
BravaisLattice = ''
if tkre.Match(r'\s*F', SPGName, 'i'):
BravaisLattice = 'F'
elif tkre.Match(r'\s*I', SPGName, 'i'):
BravaisLattice = 'I'
elif tkre.Match(r'\s*A', SPGName, 'i'):
BravaisLattice = 'A'
elif tkre.Match(r'\s*B', SPGName, 'i'):
BravaisLattice = 'B'
elif tkre.Match(r'\s*C', SPGName, 'i'):
BravaisLattice = 'C'
if BravaisLattice == '':
asl = self.ExpandedAtomSiteListByOutputMode() # このメソッドは tkSpaceGroupObject に存在すると仮定
if self.IsFaceCenteredCell(asl, EPSCoord): # このメソッドは tkSpaceGroupObject に存在すると仮定
BravaisLattice = 'F'
elif self.IsBodyCenteredCell(asl, EPSCoord): # このメソッドは tkSpaceGroupObject に存在すると仮定
BravaisLattice = 'I'
elif self.IsACenteredCell(asl, EPSCoord): # このメソッドは tkSpaceGroupObject に存在すると仮定
BravaisLattice = 'A'
elif self.IsBCenteredCell(asl, EPSCoord): # このメソッドは tkSpaceGroupObject に存在すると仮定
BravaisLattice = 'B'
elif self.IsCCenteredCell(asl, EPSCoord): # このメソッドは tkSpaceGroupObject に存在すると仮定
BravaisLattice = 'C'
else:
BravaisLattice = 'P'
return [LatticeSystem, BravaisLattice]
[ドキュメント]
def GetBravaisLattice(self):
"""
空間群名とLaue群からBravais格子タイプを返す。
詳細説明:
空間群名に含まれる中心化の記号 (P, F, I, A, B, C) とLaue群を組み合わせて、
Bravais格子の記述を生成します。
:returns: str: Bravais格子の記述文字列 (例: "P(Triclinic)", "FC(Cubic)")。
"""
SPGName = self.SPGName()
LaueGroup = self.LatticeSystem()
BravaisLattice = ''
if tkre.Match(r'\s*P', SPGName, 'i'):
BravaisLattice = "P({})".format(LaueGroup)
elif tkre.Match(r'\s*F', SPGName, 'i'):
BravaisLattice = "FC({})".format(LaueGroup)
elif tkre.Match(r'\s*I', SPGName, 'i'):
BravaisLattice = "BC({})".format(LaueGroup)
elif tkre.Match(r'\s*A', SPGName, 'i'):
BravaisLattice = "A({})".format(LaueGroup)
elif tkre.Match(r'\s*B', SPGName, 'i'):
BravaisLattice = "B({})".format(LaueGroup)
elif tkre.Match(r'\s*C', SPGName, 'i'):
BravaisLattice = "C({})".format(LaueGroup)
if BravaisLattice == 'R':
BravaisLattice = 'R(Rhombohedral)'
return BravaisLattice;
[ドキュメント]
def GetSymmetryOperationList(self):
"""
すべての対称操作のリストを返す。
:returns: list[str]: 対称操作を表す文字列のリスト。
"""
return self.__SymmetryOperation
[ドキュメント]
def SymmetryOperation(self, i):
"""
指定されたインデックスの対称操作を返す。
:param i: int: 取得する対称操作のインデックス。
:returns: str: 指定されたインデックスの対称操作を表す文字列。
"""
return self.__SymmetryOperation[i]
[ドキュメント]
def AddSymmetryOperation(self, symop):
"""
新しい対称操作を追加する。
詳細説明:
指定された文字列を解析し、対称操作としてリストに追加します。
すでに存在する場合は追加しません。
:param symop: str: 追加する対称操作を表す文字列。
:returns: int: 追加後の対称操作の総数。
"""
# symop = DelQuote(symop)
list = tkre.Search(r'([xyz\+\-\/\d,\s]+)', symop)
try:
symop = list[1]
except:
return self.__nSymmetryOperation
# pass
if symop not in self.__SymmetryOperation:
self.__SymmetryOperation.append(symop)
self.__nSymmetryOperation = len(self.__SymmetryOperation)
return self.__nSymmetryOperation
[ドキュメント]
def LatticeParameters(self):
"""
設定されている格子パラメータのリストを返す。
:returns: list[float]: 格子パラメータ [a, b, c, alpha, beta, gamma]。
"""
return self.__Latt
[ドキュメント]
def LatticeAxis(self):
"""
設定されている格子軸の名称を返す。
詳細説明:
`lattice_axis` メソッドを呼び出して格子軸の名称を取得します。
:returns: str: 格子軸の名称 (例: 'cubic', 'monoclinic')。
"""
return self.lattice_axis()
[ドキュメント]
def lattice_axis(self):
"""
設定されている格子軸の名称を返す。
詳細説明:
内部変数 `__LatticeAxis` が設定されていればそれを返し、なければ空文字列を返します。
:returns: str: 格子軸の名称 (例: 'cubic', 'monoclinic')。
"""
if self.__LatticeAxis is not None:
return self.__LatticeAxis
return ''
[ドキュメント]
def AnalyzeLatticeAxis(self, *, latticesystem = '',
SearchByLatticeParameter = 0, tollatt = 1.0e-5, tolangle = 1.0e-5):
"""
格子パラメータに基づいて格子軸の名称を解析し設定する。
詳細説明:
現在の格子パラメータ (a, b, c, alpha, beta, gamma) の値と許容誤差に基づいて、
結晶学的な格子軸（例：cubic, tetragonal, monoclinicなど）を判定し、内部変数に設定します。
:param latticesystem: str, optional: 既存の格子系名称。デフォルトは空文字列。
:param SearchByLatticeParameter: int, optional: 格子パラメータに基づいて検索するかどうかのフラグ。デフォルトは0。
:param tollatt: float, optional: 格子定数の比較に使用する許容誤差。デフォルトは1.0e-5。
:param tolangle: float, optional: 格子角の比較に使用する許容誤差。デフォルトは1.0e-5。
:returns: str: 解析された格子軸の名称。
"""
tolangle2 = tolangle * 1.01
latt = self.LatticeParameters()
if abs(latt[0] - latt[1]) < tollatt:
if abs(latt[0] - latt[2]) < tollatt:
if abs(latt[3] - 90.0) < tolangle2 \
and abs(latt[4] - 90.0) < tolangle2 \
and abs(latt[5] - 90.0) < tolangle2:
self.__LatticeAxis = 'cubic'
return self.__LatticeAxis
elif abs(latt[3] - latt[4]) < tolangle2 and abs(latt[3] - latt[5]) < tolangle2:
self.__LatticeAxis = 'trigonal'
return self.__LatticeAxis
if abs(latt[3] - 90.0) < tolangle2 \
and abs(latt[4] - 90.0) < tolangle2 \
and abs(latt[5] - 90.0) < tolangle2:
self.__LatticeAxis = 'tetragonal'
return self.__LatticeAxis
elif abs(latt[3] - 90.0) < tolangle2 \
and abs(latt[4] - 90.0) < tolangle2 \
and abs(latt[5] - 120.0) < tolangle2:
self.__LatticeAxis = 'hexagonal'
return self.__LatticeAxis
if abs(latt[3] - 90.0) < tolangle2 \
and abs(latt[4] - 90.0) < tolangle2 \
and abs(latt[5] - 90.0) < tolangle2:
self.__LatticeAxis = 'orthorhombic'
return self.__LatticeAxis
elif (abs(latt[3] - 90.0) < tolangle2 and abs(latt[4] - 90.0) < tolangle2) \
or (abs(latt[3] - 90.0) < tolangle2 and abs(latt[5] - 90.0) < tolangle2) \
or (abs(latt[4] - 90.0) < tolangle2 and abs(latt[5] - 90.0) < tolangle2):
self.__LatticeAxis = 'monoclinic'
return self.__LatticeAxis
self.__LatticeAxis = 'triclinic'
return self.__LatticeAxis
def LatticeSystem(self):
"""
設定されている格子系の名称を返す。
詳細説明:
内部変数 `__LatticeSystem` の値を返します。
:returns: str or None: 格子系の名称 (例: 'cubic', 'monoclinic')。設定されていない場合はNone。
"""
return self.__LatticeSystem
[ドキュメント]
def LatticeSystemFromSPGName(self, SPGName):
"""
空間群名称から格子系を推測し、返す。
詳細説明:
空間群名称の特定のキーワード（例: '4', '6', 'R', '2'）に基づいて
格子系（例：cubic, hexagonal, rhombohedral, monoclinic）を判断します。
:param SPGName: str: 空間群の名称。
:returns: str or None: 推測された格子系の名称 (小文字)。SPGNameが空文字列の場合はNone。
"""
if SPGName == '':
return None
if tkre.Search('4', SPGName) and tkre.Search('3', SPGName):
return 'cubic'
if tkre.Search('4', SPGName):
return 'tetragonal'
if tkre.Search('6', SPGName):
return 'hexagonal'
if tkre.Search('R', SPGName, 'i'):
return 'rhombohedral'
if tkre.Search('3', SPGName):
return 'trigonal'
if tkre.Search(r'2.*2', SPGName):
return 'orthogonal'
if tkre.Search(r'[mnabc].*[mnabc]', SPGName):
return 'orthogonal'
if tkre.Search('2', SPGName):
return 'monoclinic'
if tkre.Search('[mnabc]', SPGName):
return 'monoclinic'
return 'triclinic'
[ドキュメント]
def SetLatticeParameters(self, latt, GuessLatticeSystem = 0):
"""
格子パラメータを設定し、必要に応じて格子系と格子軸を推測する。
詳細説明:
与えられた格子パラメータ (a, b, c, alpha, beta, gamma) を内部変数に設定します。
`GuessLatticeSystem` フラグが有効な場合、設定後に格子系を自動的に解析し設定します。
:param latt: list[float]: 設定する格子パラメータ [a, b, c, alpha, beta, gamma]。
:param GuessLatticeSystem: int, optional: 格子系を自動的に推測して設定するかどうかのフラグ (0:しない, 1:する)。デフォルトは0。
"""
for i in range(6):
self.__Latt[i] = Round(latt[i], 6) if latt[i] is not None else 0.0;
self.SetLatticeSystem(SearchByLatticeParameter = GuessLatticeSystem)
self.SetLatticeAxis()
[ドキュメント]
def SetLatticeSystem(self, *, latticesystem = '',
SearchByLatticeParameter = 0, tollatt = 1.0e-5, tolangle = 1.0e-5):
"""
格子系を設定し、必要に応じて格子パラメータから推測する。
詳細説明:
明示的に格子系を設定するか、または `SearchByLatticeParameter` が有効な場合は
現在の格子パラメータから格子系を解析し設定します。空間群名から推測する場合もあります。
:param latticesystem: str, optional: 明示的に設定する格子系名称。デフォルトは空文字列。
:param SearchByLatticeParameter: int, optional: 格子パラメータに基づいて格子系を検索するかどうかのフラグ (0:しない, 1:する)。デフォルトは0。
:param tollatt: float, optional: 格子定数の比較に使用する許容誤差。デフォルトは1.0e-5。
:param tolangle: float, optional: 格子角の比較に使用する許容誤差。デフォルトは1.0e-5。
:returns: str or None: 設定または推測された格子系の名称。
"""
if latticesystem != '':
self.__LatticeSystem = latticesystem
return self.__LatticeSystem
SPGName = self.__SPGName
iSPG = self.__iSPG
iSet = self.__iSet
# print("spg=", SPGName, iSPG, iSet)
inf = self.ReadSpaceGroup(iSPG, iSet)
if inf:
self.__LatticeSystem = inf["LatticeSystem"]
return self.__LatticeSystem
latt = self.LatticeParameters()
if latt[0] == 0.0 or latt[1] == 0.0 or latt[2] == 0.0:
self._LatticeSystem = None
return self.__LatticeSystem
if SearchByLatticeParameter == 0:
if self.__LatticeSystem != '':
return self.__LatticeSystem
if self.__SPGName != '':
return self.LatticeSystemFromSPGName(SPGName)
self._LatticeSystem = self.AnalyzeLatticeAxis(tollatt, tolangle)
return self.__LatticeSystem
[ドキュメント]
def SetLatticeAxis(self, *, latticeaxis = '',
SearchByLatticeParameter = 1, tollatt = 1.0e-5, tolangle = 1.0e-5):
"""
格子軸を設定し、必要に応じて格子パラメータから推測する。
詳細説明:
明示的に格子軸を設定するか、または `SearchByLatticeParameter` が有効な場合は
現在の格子パラメータから格子軸を解析し設定します。
:param latticeaxis: str, optional: 明示的に設定する格子軸名称。デフォルトは空文字列。
:param SearchByLatticeParameter: int, optional: 格子パラメータに基づいて格子軸を検索するかどうかのフラグ (0:しない, 1:する)。デフォルトは1。
:param tollatt: float, optional: 格子定数の比較に使用する許容誤差。デフォルトは1.0e-5。
:param tolangle: float, optional: 格子角の比較に使用する許容誤差。デフォルトは1.0e-5。
:returns: str or None: 設定または推測された格子軸の名称。現在の格子パラメータが不完全な場合はNone。
"""
if latticeaxis != '':
self.__LatticeAxis = latticeaxis
return self.__LatticeAxis
latt = self.LatticeParameters()
if latt[0] == 0.0 or latt[0] == 0.0 or latt[0] == 0.0: # latt[0] == 0.0 が3回繰り返されているが、元のコードを維持
return None
if SearchByLatticeParameter == 0:
if self.__LatticeAxis != '':
return self.__LatticeSystem # __LatticeSystem を返しているが、__LatticeAxis の間違いの可能性もある。元のコードを維持
if self.__SPGName != '':
return self.__LatticeSystemFromSPGName(SPGName) # __LatticeSystemFromSPGName は存在せず、LatticeSystemFromSPGName の間違いの可能性もある。元のコードを維持
self.__LatticeAxis = self.AnalyzeLatticeAxis(tollatt = tollatt, tolangle = tolangle)
[ドキュメント]
def iLaueGroup(self):
"""
設定されているLaue群のインデックスを返す。
詳細説明:
内部変数 `__iLaueG` の値を返します。
:returns: int: Laue群のインデックス。
"""
return self.__iLaueG
[ドキュメント]
def SetiLaueGroup(self, iLaueG = None):
"""
Laue群のインデックスを設定する。
詳細説明:
与えられたインデックスで内部変数 `__iLaueG` を更新します。
引数がNoneの場合は何もしません（`LaueGroupByRietanIndex` が呼び出されますが、その結果は使われません）。
:param iLaueG: int, optional: 設定するLaue群のインデックス。デフォルトはNone。
"""
if iLaueG is not None:
self.__iLaueG = iLaueG
else:
self.__iLaueG = self.LaueGroupByRietanIndex(iLaueG); # iLaueG が None の場合、この呼び出しは常に空文字列を返し、__iLaueG が空文字列になるが、元のコードを維持。
# self.SetLatticeSystem(self.LatticeSystemFromLaueGroup(self.__LaueG))
[ドキュメント]
def LatticeSystem(self):
"""
設定されている格子系の名称を返す。
詳細説明:
内部変数 `__LatticeSystem` の値を返します。
:returns: str or None: 格子系の名称 (例: 'cubic', 'monoclinic')。
"""
return self.__LatticeSystem