예제 #1
0
def test_coord_trans():
    natoms = 10
    cell = np.array([[3, 0, 0], [1.1, 5, -0.04], [-0.33, 1.5, 7]])
    cryst_const = crys.cell2cc(cell)
    coords_frac = rand(natoms, 3)
    coords = crys.coord_trans(coords=coords_frac, old=cell, new=np.identity(3))

    st = crys.Structure(coords=coords, cell=cell)
    assert np.allclose(coords_frac, st.coords_frac)
    st = crys.Structure(coords_frac=coords_frac, cell=cell)
    assert np.allclose(coords, st.coords)

    st = crys.Structure(coords=coords, cell=cell)
    assert np.allclose(cryst_const, st.cryst_const)
예제 #2
0
def test_get_ase_atoms():
    natoms = 10
    st = crys.Structure(coords_frac=rand(natoms, 3),
                        symbols=['H'] * 10,
                        cell=rand(3, 3))
    try:
        import ase
        st2 = crys.atoms2struct(crys.struct2atoms(st))
        keys = [
            'natoms', 'coords', 'coords_frac', 'symbols', 'cryst_const',
            'cell', 'volume', 'mass'
        ]
        tools.assert_dict_with_all_types_almost_equal(\
            st.__dict__,
            st2.__dict__,
            keys=keys,
            strict=True)
        # in case the test fails, use this to find out which key failed
        ##        for kk in keys:
        ##            print("testing: %s ..." %kk)
        ##            tools.assert_all_types_almost_equal(st.__dict__[kk], st2.__dict__[kk])
        for pbc in [True, False]:
            at = st.get_ase_atoms(pbc=pbc)
            assert (at.pbc == np.array([pbc] * 3)).all()
            at = crys.struct2atoms(st, pbc=pbc)
            assert (at.pbc == np.array([pbc] * 3)).all()
    except ImportError:
        tools.skip("cannot import ase, skipping test get_ase_atoms()")
예제 #3
0
def test_methods():
    tr = crys.Trajectory(coords=rand(100, 10, 3),
                         cell=rand(100, 3, 3),
                         symbols=['H'] * 10)
    st = crys.Structure(coords=rand(10, 3),
                        cell=rand(3, 3),
                        symbols=['H'] * 10)

    for obj, indices in [(st, [0, 1, 2]), (tr, [0, 0, 1, 2])]:
        if obj.is_traj:
            v0 = obj.coords[indices[0], indices[1], ...]
            v1 = obj.coords[indices[0], indices[2], ...]
            v2 = obj.coords[indices[0], indices[3], ...]
        else:
            v0 = obj.coords[indices[0], ...]
            v1 = obj.coords[indices[1], ...]
            v2 = obj.coords[indices[2], ...]
        # use eps=0 since the new system is not orthogonal, only test API
        o1 = crys.align_cart(obj, x=v1 - v0, y=v2 - v0, eps=0)
        o2 = crys.align_cart(obj, vecs=np.array([v0, v1, v2]), eps=0)
        o3 = crys.align_cart(obj, indices=indices, eps=0)
        tools.assert_dict_with_all_types_almost_equal(o1.__dict__,
                                                      o2.__dict__,
                                                      keys=o1.attr_lst)
        tools.assert_dict_with_all_types_almost_equal(o1.__dict__,
                                                      o3.__dict__,
                                                      keys=o1.attr_lst)
예제 #4
0
def test_pbc_wrap():
    coords_frac_orig = np.array([[1.1, 0.9, -0.1], [-0.8, 0.5, 0.0]])
    st = crys.Structure(coords_frac=coords_frac_orig,
                        cell=np.identity(3) * 2,
                        symbols=['H'] * 2)
    st_wrap = crys.pbc_wrap(st)
    # pbc_wrap() makes a copy by default, make sure the original st is unchanged
    assert (st.coords_frac == coords_frac_orig).all()
    assert (st.coords == coords_frac_orig * 2.0).all()
    coords_frac_wrap = np.array([[0.1, 0.9, 0.9], [0.2, 0.5, 0.]])
    assert np.allclose(coords_frac_wrap, st_wrap.coords_frac)
    assert np.allclose(coords_frac_wrap, st_wrap.coords / 2.0)

    coords_frac_wrap = np.random.rand(20, 100, 3)
    plus = np.random.randint(-1, 1, coords_frac_wrap.shape)
    coords_frac_orig = coords_frac_wrap + plus
    tr = crys.Trajectory(coords_frac=coords_frac_orig,
                         cell=np.identity(3) * 2.0,
                         symbols=['H'] * 100)

    tr_wrap = crys.pbc_wrap(tr, xyz_axis=-1)
    assert (tr.coords_frac == coords_frac_orig).all()
    assert (tr.coords == coords_frac_orig * 2.0).all()
    assert np.allclose(coords_frac_orig[plus == 0],
                       tr_wrap.coords_frac[plus == 0])
    assert np.allclose(coords_frac_orig[plus == -1] + 1,
                       tr_wrap.coords_frac[plus == -1])
    assert np.allclose(coords_frac_orig[plus == 1] - 1,
                       tr_wrap.coords_frac[plus == 1])
    assert np.allclose(coords_frac_wrap, tr_wrap.coords_frac)
    assert np.allclose(coords_frac_wrap, tr_wrap.coords / 2.0)

    tr_wrap = crys.pbc_wrap(tr, mask=[True, True, False], xyz_axis=-1)
    assert np.allclose(tr.coords_frac[..., 2], tr_wrap.coords_frac[..., 2])
예제 #5
0
def test_save_mkdir():
    path = os.path.join(testdir, 'foo', 'bar', 'baz')
    assert not os.path.exists(path)
    fn = os.path.join(path, 'grr.pk')
    st = crys.Structure(coords=rand(10,3), cell=rand(3,3), symbols=['H']*10)
    st.dump(fn, mkdir=True)
    io.read_pickle(fn)
예제 #6
0
def test_write_lammps():
    st = crys.Structure(coords_frac=rand(20, 3),
                        cell=rand(3, 3),
                        symbols=['Al'] * 10 + ['N'] * 10)
    # align cell to lammps standard [[x,0,0],...]
    st.coords = None
    st.cell = None
    st.set_all()
    st_fn = common.pj(testdir, 'lmp.struct')
    io.write_lammps(st_fn, st)
    symbols = common.file_read(st_fn + '.symbols').split()
    assert st.symbols == symbols
    cmd = r"grep -A22 Atoms %s | grep '^[0-9]'" % st_fn
    arr = parse.arr2d_from_txt(common.backtick(cmd))
    assert arr.shape == (20, 5)
    assert np.allclose(st.coords, arr[:, 2:])
예제 #7
0
def test_fdist():
    
    natoms = 5
    coords_frac = np.random.rand(natoms,3)
    cell = np.random.rand(3,3)*3
    struct = crys.Structure(coords_frac=coords_frac,
                            cell=cell)
    
    for pbc in [0,1]:
        print("pbc:", pbc)
        pyret = pydist(coords_frac, cell, pbc)
        # uses _flib.distsq_frac()
        pyret2 = crys.distances(struct, pbc=pbc, squared=True, fullout=True)
        for ii in [0,1,2]:
            print(ii)
            assert np.allclose(pyret[ii], pyret2[ii])
예제 #8
0
def test_correct():
    coords = rand(20, 3)
    cell = rand(3, 3)
    st = crys.Structure(coords=coords, cell=cell, symbols=['H'])
    # new cartesian coord sys, created by rotating the old E=identity(3) by 3
    # random angles
    angles = [rand() * 360, rand() * 180, rand() * 360]
    rmat = euler_rotation(*tuple(angles))
    newcoords = np.array([np.dot(rmat, x) for x in st.coords])
    newcell = np.array([np.dot(rmat, x) for x in st.cell])
    st2 = crys.align_cart(st, cart=rmat, eps=1e-3)
    assert np.allclose(newcoords, np.dot(st.coords, rmat.T))
    assert np.allclose(
        newcoords, crys.coord_trans(st.coords, old=np.identity(3), new=rmat))
    assert np.allclose(newcell, np.dot(st.cell, rmat.T))
    assert np.allclose(newcell,
                       crys.coord_trans(st.cell, old=np.identity(3), new=rmat))
    assert np.allclose(st2.coords, newcoords)
예제 #9
0
def test_symmetry():
    tools.skip_if_pkg_missing('pyspglib')
    st_prim = crys.Structure(coords_frac=np.array([[0] * 3, [.5] * 3]),
                             cryst_const=np.array([3.5] * 3 + [60] * 3),
                             symbols=['Al', 'N'])
    st_sc = crys.scell(st_prim, (2, 3, 4))
    st_prim2 = symmetry.spglib_get_primitive(st_sc, symprec=1e-2)
    # irreducible structs
    assert symmetry.spglib_get_primitive(st_prim, symprec=1e-2) is None
    assert symmetry.spglib_get_primitive(st_prim2, symprec=1e-2) is None
    for st in [st_prim, st_sc, st_prim2]:
        assert symmetry.spglib_get_spacegroup(st_prim,
                                              symprec=1e-2) == (225, 'Fm-3m')
    # this is redundant since we have is_same_struct(), but keep it anyway
    tools.assert_dict_with_all_types_almost_equal(
        st_prim.__dict__,
        st_prim2.__dict__,
        keys=['natoms', 'symbols', 'volume', 'cryst_const'])
    assert symmetry.is_same_struct(st_prim, st_prim2)
예제 #10
0
{ensemble}
timestep 0.5e-3
run 1000
"""

assert len(sys.argv) == 2, "need one input arg: nvt or npt"
if sys.argv[1] == 'npt':
    ens_txt = npt_txt
elif sys.argv[1] == 'nvt':    
    ens_txt = nvt_txt
else:
    raise Exception("only nvt / npt allowed")

# create structure file
st = crys.Structure(coords_frac=np.array([[0.0]*3, [.5]*3]),
                    cryst_const=np.array([2.85]*3 + [60]*3),
                    symbols=['Al','N'])
io.write_lammps('lmp.struct', crys.scell(st,(3,3,3)))

# write lmp.in for nvt or npt
common.file_write('lmp.in', lmp_in_templ.format(ensemble=ens_txt))

# run lammps
common.system("mpirun -np 2 lammps < lmp.in", wait=True)

# read trajectory
trtxt_orig = io.read_lammps_md_txt('log.lammps')
trdcd = io.read_lammps_md_dcd('log.lammps')

# plotting
plots = mpl.prepare_plots(['coords', 'coords_frac', 'velocity', 
예제 #11
0
파일: rpdf_aln.py 프로젝트: zari277/pwtools
    #
    coords_frac = \
        np.array([[0.0, 0.0, 0.0], 
                  [0.5, 0.0, 0.0],
                  [0.0, 0.5, 0.0],
                  [0.5, 0.5, 0.0],
                  [0.0, 0.0, 0.5],
                  [0.5, 0.0, 0.5],
                  [0.0, 0.5, 0.5],
                  [0.5, 0.5, 0.5],
                  ])
    symbols = ['Al', 'N', 'N', 'Al', 'N', 'Al', 'Al', 'N']
    alat = 5.0
    cell = np.identity(3) * alat
    struct = crys.Structure(coords_frac=coords_frac,
                            symbols=symbols,
                            cell=cell)
    sc = crys.scell(struct, (2,2,2))
    name = 'aln_ibrav0_sc'
    structs[name] = Struct(coords_frac=sc.coords_frac, 
                           cell=sc.cell,
                           symbols=sc.symbols,
                           fnbase=name,
                           tgtdir=tgtdir)
    print(structs[name].cryst_const)                            
##    structs[name].write_cif()
##    structs[name].write_axsf()
##    structs[name].savetxt()

    
    # AlN ibrav=2