pbcpy 0.2.7

DirectCell 和 ReciprocalCell 属性；

• lattice：晶格矢量（作为列）；

• volume：晶胞的体积；

• origin：笛卡尔参考系的起点；

# the lattice
>>> cell1.lattice
array([[ 10.,   0.,   0.],
       [  0.,  10.,   0.],
       [  0.,   0.,  10.]])

# the volume
>>> cell1.volume
1000.0

DirectCell 和 ReciprocalCell 方法；

• == 操作符：比较两个 Cell 对象；

• get_reciprocal：返回一个新的 ReciprocalCell 对象，它是 self 的“倒数”晶胞（如果 self 是 DirectCell）；

• get_direct：返回一个新的 DirectCell 对象，它是 self 的“直接”晶胞（如果 self 是 ReciprocalCell）；

注意，在将直接晶格和倒易晶格之间转换时，默认使用物理约定；

\big[\text{reciprocal.lattice}\big]^T = 2\pi \cdot \big[\text{direct.lattice}\big]^{-1}

>>> reciprocal_cell1 = cell1.get_reciprocal()
>>> print(reciprocal_cell1.lattice)
array([[ 0.62831853,  0. ,  0. ],
       [ 0. ,  0.62831853,  0. ],
       [ 0. ,  0. ,  0.62831853]])

>>> cell2 = reciprocal_cell1.get_direct()
>>> print(cell2.lattice)
array([[ 10.,  0.,  0.],
       [ 0.,  10.,  0.],
       [ 0.,  0.,  10.]])

>>> cell1 == cell2
True

Coord 属性；

• basis：坐标类型：'Cartesian' 或 'Crystal'。

• cell：与坐标相关联的 DirectCell 对象。

# the coordinate type (Cartesian or Crystal)
>>> pos1.basis
'Cartesian'

# the cell attribute is a Cell object
>>> type(pos1.cell)
pbcpy.base.DirectCell

Coord 方法；

• to_crys()，to_cart()：将 self 转换为晶体或笛卡尔基础（返回一个新的 Coord 对象）。

• d_mic(other)：计算连接两个坐标的矢量（从 self 到 other），使用最小图像公约（MIC）。结果是本身也是一个 Coord 对象。

• dd_mic(other)：使用 MIC 计算两个坐标之间的距离。

• +/- 操作符：在不使用 MIC 的情况下计算两个坐标之间的差/和。当需要时自动执行基础转换。结果是本身也是一个 Coord 对象。

>>> pos1 = Coord(pos=[0.5,0.0,1.0], cell=cell1, ctype="Crystal")
>>> pos2 = Coord(pos=[0.6,-1.0,3.0], cell=cell1, ctype="Crystal")

# convert to Crystal or Cartesian (returns new object)
>>> pos1.to_cart()
Coord([  5.,   0.,  10.]) # the coordinate was already Cartesian, the result is still correct.
>>> pos1.to_crys()
Coord([ 0.5,  0. ,  1. ]) # the coordinate was already Crystal, the result is still correct.

## vector connecting two coordinates (using the minimum image convention), and distance
>>> pos1.d_mic(pos2)
Coord([ 0.1,  0. ,  0. ])
>>> pos1.dd_mic(pos2)
0.99999999999999978

## vector connecting two coordinates (without using the minimum image convention) and distance
>>> pos2 - pos1
Coord([ 0.1, -1. ,  2. ])
>>> (pos2 - pos1).length()
22.383029285599392

Grid 属性

• 从 Cell 继承的所有属性

• dV：单一点的体积，当计算积分量时很有用

• nr：数组，每个方向的网格点数

• nnr：网格中的总点数

• r：每个网格点的笛卡尔坐标。一个类型为 Coord 的 3 级数组（仅限 DirectGrid）

• s：每个网格点的晶体坐标。一个类型为 Coord 的 3 级数组（仅限 DirectGrid）

• g：每个网格点的 G 矢量（仅限 ReciprocalGrid）

• gg：每个网格点的 G 矢量的平方（仅限 ReciprocalGrid）

# The volume of each point
>>> grid1.dV
0.001

# Grid points for each direction
>>> grid1.nr
array([100, 100, 100])

# Total number of grid points
>>> grid1.nnr
1000000

# Cartesian coordinates at each grid point
>>> grid1.r
Coord([[[[ 0. ,  0. ,  0. ],
         [ 0. ,  0. ,  0.1],
         [ 0. ,  0. ,  0.2],
         [ 0. ,  0. ,  0.3],
                        ...]]])

>>> grid1.r.shape
(100, 100, 100, 3)

>>> grid1.r[0,49,99]
Coord([ 0. ,  4.9,  9.9])

# Crystal coordinates at each grid point
>>> grid1.s
Coord([[[[ 0.  ,  0.  ,  0.  ],
     [ 0.  ,  0.  ,  0.01],
         [ 0.  ,  0.  ,  0.02],
         [ 0.  ,  0.  ,  0.03],
              ...]]]])

# Since DirectGrid inherits from DirectCell, we can still use the get_reciprocal methos
reciprocal_grid1 = grid1.get_reciprocal()

# reciprocal_grid1 is an instance of ReciprocalGrid
>>> reciprocal_grid1.g
array([[[[ 0.  ,  0.  ,  0.  ],
         [ 0.  ,  0.  ,  0.01],
         [ 0.  ,  0.  ,  0.02],
         ...,
         [ 0.  ,  0.  , -0.03],
         [ 0.  ,  0.  , -0.02],
         [ 0.  ,  0.  , -0.01]],
                   ...]]])

>>> reciprocal_grid1.g.shape
(100, 100, 100, 3)

>>> reciprocal_grid1.gg
array([[[ 0.    ,  0.0001,  0.0004, ...,  0.0009,  0.0004,  0.0001],
        [ 0.0001,  0.0002,  0.0005, ...,  0.001 ,  0.0005,  0.0002],
        [ 0.0004,  0.0005,  0.0008, ...,  0.0013,  0.0008,  0.0005],
        ...,
        [ 0.0009,  0.001 ,  0.0013, ...,  0.0018,  0.0013,  0.001 ],
        [ 0.0004,  0.0005,  0.0008, ...,  0.0013,  0.0008,  0.0005],
        [ 0.0001,  0.0002,  0.0005, ...,  0.001 ,  0.0005,  0.0002]],
        ...,
                                                                  ]])

>>> reciprocal_grid1.gg.shape
(100, 100, 100)

DirectField 属性

• grid：表示与场相关的网格（它是一个 DirectGrid 或 ReciprocalGrid 对象）

• span：具有大于 1 的点数的网格的维度数

• rank：每个网格点上量的维度数

  • 1：标量场（例如，rho 的秩为 1）

  • >1：矢量场（例如，rho 的梯度的秩为 3）

>>> type(rho.grid)
pbcpy.grid.DirectGrid

>>> rho.span
3

>>> rho.rank
1
# the density is a scalar field

DirectField 方法

• 从 numpy.array 继承的任何方法。

• integral：返回场的积分。

• get_3dinterpolation：将数据插值到不同的网格（返回一个新的 DirectField 对象）。3 阶样条插值。

• get_cut(r0, [r1], [r2], [origin], [center], [nr])：通过提供任意向量和原点/中心来获取标量场的 1D/2D/3D 切片。

• fft：计算自变量的傅里叶变换，并返回一个 ReciprocalField 实例，其中包含适当的 ReciprocalGrid

# Integrate the field over the whole grid
>>> rho.integral()
16.000000002898673 # the electron density of a water dimer has 16 valence electrons as expected

# Interpolate the scalar field from one grid to another
>>> rho.shape
(125, 125, 125)

>>> rho_interp = rho.get_3dinterpolation([90,90,90])
>>> rho_interp.shape
(90, 90, 90)

>> rho_interp.integral()
15.999915251442873


# Get arbitrary cuts of the scalar field.
# In this example get the cut of the electron density in the plane of the water molecule
>>> ppfile = "/path/to/density.pp"
>>> water_dimer = PP(ppfile).read()

>>> o_pos = water_dimer.ions[0].pos
>>> h1_pos = water_dimer.ions[1].pos
>>> h2_pos = water_dimer.ions[2].pos

>>> rho_cut = rho.get_cut(r0=o_h1_vec*4, r1=o_h2_vec*4, center=o_pos, nr=[100,100])

# plot_cut is itself a DirectField instance, and it can be either exported to an xsf file (see next session)
# or its values can be analized/manipulated in place.
>>> rho_cut.shape
(100,100)
>>> rho_cut.span
2
>>> rho_cut.grid.lattice
array([[ 1.57225214, -6.68207161, -0.43149218],
       [-1.75366585, -3.04623853,  0.8479004 ],
       [-7.02978121,  0.97509868, -0.30802502]])

# plot_cut is itself a Grid_Function_Base instance, and it can be either exported to an xsf file (see next session)
# or its values can be analized/manipulated in place.
>>> plot_cut.values.shape
(200, 200)

# Fourier transform of the DirectField
>>> rho_g = rho.fft()
>>> type(rho_g)
pbcpy.field.ReciprocalField

ReciprocalField 方法

• ifft：计算自变量的逆傅里叶变换，并返回一个 DirectField 实例，其中包含适当的 DirectGrid

# inv fft:
# recall that rho_g = fft(rho)
>>> rho1 = rho_g.ifft()
>>> type(rho1)
pbcpy.field.DirectField

>>> rho1.grid == rho.grid
True

>>> np.isclose(rho1, rho).all()
True
# as expected ifft(fft(rho)) = rho

System 属性

• 名称 : 任意名称

• 离子 : 原子集合及其坐标

• 晶胞 : 系统的单位晶胞（DirectCell 或 DirectGrid）

• 场 : 可选的 DirectField 对象。

PP 类

pbcpy 可以将 Quantum Espresso 后处理 .pp 文件读取到 System 对象中。

>>> water_dimer = PP(filepp='/path/to/density.pp').read()
# the output of PP.read() is a System object.

XSF 类

pbcpy 可以将 System 对象写入 XCrySDen 的 .xsf 文件。

>>> XSF(filexsf='/path/to/output.xsf').write(system=water_dimer)

# an optional field parameter can be passed to XSF.write() in order to override the DirectField in system.
# This is especially useful if one wants to output one system and an arbitrary cut of the grid,
# such as the one we generated earlier
>>> XSF(filexsf='/path/to/output.xsf').write(system=water_dimer, field=rho_cut)