Beispiel #1
0
def test_cell_tools():
    # test known values: simple cubic
    cell_a = 5.0
    cell = np.identity(3) * cell_a
    volume = cell_a**3.0
    cryst_const = np.array([cell_a] * 3 + [90.0] * 3)
    np.testing.assert_array_almost_equal(crys.cell2cc(cell), cryst_const)
    np.testing.assert_array_almost_equal(crys.cc2cell(cryst_const), cell)
    np.testing.assert_almost_equal(volume, crys.volume_cc(cryst_const))
    np.testing.assert_almost_equal(volume, crys.volume_cell(cell))
    np.testing.assert_array_almost_equal(crys.cc2cell(crys.cell2cc(cell)),
                                         cell)
    np.testing.assert_array_almost_equal(
        crys.cell2cc(crys.cc2cell(cryst_const)), cryst_const)

    # random
    #
    # volume : volume_cc() always returns positive values, whereas det() and
    #     volume_cell() may return the volume with negative sign but correct
    #     magnitude.
    # cell : A random cell does also have a random orientation in space. It
    #     does NOT conform the usual convention: a along x, b in x-y plane.
    #     However, the cryst_const and volume must be invariant.
    cell = np.random.rand(3, 3)
    cryst_const = crys.cell2cc(cell)
    volume = abs(np.linalg.det(cell))
    np.testing.assert_almost_equal(volume, crys.volume_cc(cryst_const))
    np.testing.assert_almost_equal(volume, abs(crys.volume_cell(cell)))
    # this must always fail for random cells
    try:
        np.testing.assert_array_almost_equal(crys.cc2cell(crys.cell2cc(cell)),
                                             cell)
    except AssertionError:
        pass
    # Here, we convert cryst_const to a *different* cell which conforms to the
    # orientation convention, and back to cryst_const.
    np.testing.assert_array_almost_equal(
        crys.cell2cc(crys.cc2cell(cryst_const)), cryst_const)

    # 3d
    cell = rand(100, 3, 3)
    cc = crys.cell2cc3d(cell, axis=0)
    vol_cell = np.abs(crys.volume_cell3d(cell, axis=0))
    vol_cc = crys.volume_cc3d(cc, axis=0)

    assert crys.cell2cc3d(cell, axis=0).shape == (100, 6)
    assert crys.cc2cell3d(cc, axis=0).shape == (100, 3, 3)

    assert vol_cc.shape == (100, )
    assert vol_cell.shape == (100, )
    aaae(vol_cell, vol_cc)
    aaae(crys.cell2cc3d(crys.cc2cell3d(cc)), cc)
def test_cell_tools():
    # test known values: simple cubic
    cell_a = 5.0
    cell = np.identity(3)*cell_a
    volume = cell_a**3.0
    cryst_const = np.array([cell_a]*3 + [90.0]*3)
    np.testing.assert_array_almost_equal(crys.cell2cc(cell), cryst_const)
    np.testing.assert_array_almost_equal(crys.cc2cell(cryst_const), cell)
    np.testing.assert_almost_equal(volume, crys.volume_cc(cryst_const))
    np.testing.assert_almost_equal(volume, crys.volume_cell(cell))
    np.testing.assert_array_almost_equal(crys.cc2cell(crys.cell2cc(cell)), cell)
    np.testing.assert_array_almost_equal(crys.cell2cc(crys.cc2cell(cryst_const)),
                                         cryst_const)
                                         
    # random
    #
    # volume : volume_cc() always returns positive values, whereas det() and
    #     volume_cell() may return the volume with negative sign but correct
    #     magnitude.
    # cell : A random cell does also have a random orientation in space. It
    #     does NOT conform the usual convention: a along x, b in x-y plane.
    #     However, the cryst_const and volume must be invariant.
    cell = np.random.rand(3,3)
    cryst_const = crys.cell2cc(cell)
    volume = abs(np.linalg.det(cell))
    np.testing.assert_almost_equal(volume, crys.volume_cc(cryst_const))
    np.testing.assert_almost_equal(volume, abs(crys.volume_cell(cell)))
    # this must always fail for random cells
    try:
        np.testing.assert_array_almost_equal(crys.cc2cell(crys.cell2cc(cell)), cell)
    except AssertionError:
        pass
    # Here, we convert cryst_const to a *different* cell which conforms to the
    # orientation convention, and back to cryst_const.
    np.testing.assert_array_almost_equal(crys.cell2cc(crys.cc2cell(cryst_const)),
                                         cryst_const)

    # 3d
    cell = rand(100,3,3)
    cc = crys.cell2cc3d(cell, axis=0)
    vol_cell = np.abs(crys.volume_cell3d(cell, axis=0))
    vol_cc = crys.volume_cc3d(cc, axis=0)

    assert crys.cell2cc3d(cell, axis=0).shape == (100,6)
    assert crys.cc2cell3d(cc, axis=0).shape == (100,3,3)
    
    assert vol_cc.shape == (100,)
    assert vol_cell.shape == (100,)
    aaae(vol_cell, vol_cc)
    aaae(crys.cell2cc3d(crys.cc2cell3d(cc)), cc)
Beispiel #3
0
def test_dist_traj():
    natoms = 10
    nstep = 100
    cell = rand(nstep, 3, 3)
    stress = rand(nstep, 3, 3)
    forces = rand(nstep, natoms, 3)
    etot = rand(nstep)
    cryst_const = crys.cell2cc3d(cell, axis=0)
    coords_frac = np.random.rand(nstep, natoms, 3)
    coords = crys.coord_trans3d(coords=coords_frac,
                                old=cell,
                                new=num.extend_array(np.identity(3),
                                                     nstep,
                                                     axis=0),
                                axis=1,
                                timeaxis=0)
    assert cryst_const.shape == (nstep, 6)
    assert coords.shape == (nstep, natoms, 3)
    symbols = ['H'] * natoms

    traj = Trajectory(
        coords_frac=coords_frac,
        cell=cell,
        symbols=symbols,
        forces=forces,
        stress=stress,
        etot=etot,
        timestep=1,
    )

    for pbc in [True, False]:
        # (nstep, natoms, natoms, 3)
        distvecs_frac = traj.coords_frac[:,:,None,:] - \
                        traj.coords_frac[:,None,:,:]
        assert distvecs_frac.shape == (nstep, natoms, natoms, 3)
        if pbc:
            distvecs_frac = crys.min_image_convention(distvecs_frac)
        distvecs = np.empty((nstep, natoms, natoms, 3))
        for ii in range(traj.nstep):
            distvecs[ii, ...] = np.dot(distvecs_frac[ii, ...], traj.cell[ii,
                                                                         ...])
        # (nstep, natoms, natoms)
        dists = np.sqrt((distvecs**2.0).sum(axis=-1))
        assert np.allclose(dists, crys.distances_traj(traj, pbc=pbc))
Beispiel #4
0
def test_coords_trans():
    natoms = 10
    nstep = 100
    cell = rand(nstep, 3, 3)
    cryst_const = crys.cell2cc3d(cell, axis=0)
    coords_frac = rand(nstep, natoms, 3)
    coords = crys.coord_trans3d(coords=coords_frac,
                                old=cell,
                                new=num.extend_array(np.identity(3),
                                                     nstep,
                                                     axis=0),
                                axis=1,
                                timeaxis=0)

    traj = Trajectory(coords_frac=coords_frac, cell=cell)
    assert np.allclose(cryst_const, traj.cryst_const)
    assert np.allclose(coords, traj.coords)

    traj = Trajectory(coords=coords, cell=cell)
    assert np.allclose(coords_frac, traj.coords_frac)
Beispiel #5
0
def test_dist_traj():
    natoms = 10
    nstep = 100
    cell = rand(nstep,3,3)
    stress = rand(nstep,3,3)
    forces = rand(nstep,natoms,3)
    etot=rand(nstep)
    cryst_const = crys.cell2cc3d(cell, axis=0)
    coords_frac = np.random.rand(nstep,natoms,3)
    coords = crys.coord_trans3d(coords=coords_frac,
                                old=cell,
                                new=num.extend_array(np.identity(3),
                                                     nstep,axis=0),
                                axis=1,
                                timeaxis=0)                                                    
    assert cryst_const.shape == (nstep, 6)
    assert coords.shape == (nstep,natoms,3)
    symbols = ['H']*natoms
    
    traj = Trajectory(coords_frac=coords_frac,
                      cell=cell,
                      symbols=symbols,
                      forces=forces,
                      stress=stress,
                      etot=etot,
                      timestep=1,
                      )
    
    for pbc in [True, False]:
        # (nstep, natoms, natoms, 3)
        distvecs_frac = traj.coords_frac[:,:,None,:] - \
                        traj.coords_frac[:,None,:,:]
        assert distvecs_frac.shape == (nstep, natoms, natoms, 3)
        if pbc:
            distvecs_frac = crys.min_image_convention(distvecs_frac)
        distvecs = np.empty((nstep, natoms, natoms, 3))
        for ii in range(traj.nstep):
            distvecs[ii,...] = np.dot(distvecs_frac[ii,...], traj.cell[ii,...])
        # (nstep, natoms, natoms)
        dists = np.sqrt((distvecs**2.0).sum(axis=-1))
        assert np.allclose(dists, crys.distances_traj(traj, pbc=pbc))
Beispiel #6
0
def test_coords_trans():
    natoms = 10
    nstep = 100
    cell = rand(nstep,3,3)
    cryst_const = crys.cell2cc3d(cell, axis=0)
    coords_frac = rand(nstep,natoms,3)
    coords = crys.coord_trans3d(coords=coords_frac,
                                old=cell,
                                new=num.extend_array(np.identity(3),
                                                     nstep,axis=0),
                                axis=1,
                                timeaxis=0)                                                    
    
    traj = Trajectory(coords_frac=coords_frac,
                      cell=cell)
    assert np.allclose(cryst_const, traj.cryst_const)
    assert np.allclose(coords, traj.coords)
    
    traj = Trajectory(coords=coords,
                      cell=cell)
    assert np.allclose(coords_frac, traj.coords_frac)
Beispiel #7
0
def test_traj():
    natoms = 10
    nstep = 100
    cell = rand(nstep,3,3)
    stress = rand(nstep,3,3)
    forces = rand(nstep,natoms,3)
    etot = rand(nstep)
    cryst_const = crys.cell2cc3d(cell, axis=0)
    coords_frac = rand(nstep,natoms,3)
    coords = crys.coord_trans3d(coords=coords_frac,
                                old=cell,
                                new=num.extend_array(np.identity(3),
                                                     nstep,axis=0),
                                axis=1,
                                timeaxis=0)                                                    
    assert cryst_const.shape == (nstep, 6)
    assert coords.shape == (nstep,natoms,3)
    symbols = ['H']*natoms
    
    # automatically calculated:
    #   coords
    #   cell
    #   pressure
    #   velocity (from coords)
    #   temperature (from ekin)
    #   ekin (from velocity)
    traj = Trajectory(coords_frac=coords_frac,
                    cell=cell,
                    symbols=symbols,
                    forces=forces,
                    stress=stress,
                    etot=etot,
                    timestep=1,
                    )
    # Test if all getters work.
    for name in traj.attr_lst:
        print "test if getters work:", name
        traj.try_set_attr(name)
        assert getattr(traj, name) is not None, "attr None: %s" %name
        assert eval('traj.get_%s()'%name) is not None, "getter returns None: %s" %name
        print "test if getters work:", name, "... ok"
    aaae(coords_frac, traj.coords_frac)
    aaae(coords, traj.coords)
    aaae(cryst_const, traj.cryst_const)
    aaae(np.trace(stress, axis1=1, axis2=2)/3.0, traj.pressure)
    assert traj.coords.shape == (nstep,natoms,3)
    assert traj.cell.shape == (nstep,3,3)
    assert traj.velocity.shape == (nstep, natoms, 3)
    assert traj.temperature.shape == (nstep,)
    assert traj.ekin.shape == (nstep,)
    assert traj.nstep == nstep
    assert traj.natoms == natoms

    traj = Trajectory(coords_frac=coords_frac,
                    symbols=symbols,
                    cell=cell)
    aaae(coords, traj.coords)
    
    # Cell calculated from cryst_const has defined orientation in space which may be
    # different from the original `cell`, but the volume and underlying cryst_const
    # must be the same.
    traj = Trajectory(coords_frac=coords_frac,
                    symbols=symbols,
                    cryst_const=cryst_const)
    np.testing.assert_almost_equal(crys.volume_cell3d(cell),
                                   crys.volume_cell3d(traj.cell))
    aaae(cryst_const, crys.cell2cc3d(traj.cell))
    
    # extend arrays
    cell2d = rand(3,3)
    cc2d = crys.cell2cc(cell2d)
    traj = Trajectory(coords_frac=coords_frac,
                      cell=cell2d,
                      symbols=symbols)
    assert traj.cell.shape == (nstep,3,3)
    assert traj.cryst_const.shape == (nstep,6)
    for ii in range(traj.nstep):
        assert (traj.cell[ii,...] == cell2d).all()
        assert (traj.cryst_const[ii,:] == cc2d).all()
    
    traj = Trajectory(coords_frac=coords_frac,
                      cryst_const=cc2d,
                      symbols=symbols)
    assert traj.cell.shape == (nstep,3,3)
    assert traj.cryst_const.shape == (nstep,6)
    for ii in range(traj.nstep):
        assert (traj.cryst_const[ii,:] == cc2d).all()

    # units
    traj = Trajectory(coords_frac=coords_frac,
                    cell=cell,
                    symbols=symbols,
                    stress=stress,
                    forces=forces,
                    units={'length': 2, 'forces': 3, 'stress': 4})
    aaae(2*coords, traj.coords)                    
    aaae(3*forces, traj.forces)                    
    aaae(4*stress, traj.stress)                    
    
    # iterate, check if Structures are complete
    traj = Trajectory(coords=coords, 
                      symbols=symbols,
                      cell=cell,
                      forces=forces,
                      stress=stress,
                      etot=etot,
                      timestep=1.0)
    for struct in traj:
        assert struct.is_struct, "st is not Structure"
        assert not struct.is_traj, "st is Trajectory"
        assert_attrs_not_none(struct)
    struct = traj[0]
    for attr_name in traj.attr_lst:
        if attr_name in struct.attrs_only_traj:
            msg = "tr[0] %s is not None" %attr_name
            assert getattr(struct,attr_name) is None, msg
        else:            
            msg = "tr[0] %s is None" %attr_name
            assert getattr(struct,attr_name) is not None, msg
    
    # slices, return traj
    keys = traj.attr_lst[:]
    tsl = traj[10:80:2]
    assert tsl.nstep == traj.nstep / 2 - 15
    assert_attrs_not_none(tsl, attr_lst=keys)
    tsl = traj[slice(10,80,2)]
    assert tsl.nstep == traj.nstep / 2 - 15
    assert_attrs_not_none(tsl, attr_lst=keys)
    tsl = traj[np.s_[10:80:2]]
    assert tsl.nstep == traj.nstep / 2 - 15
    assert_attrs_not_none(tsl, attr_lst=keys)
    assert tsl.is_traj
    
    # iteration over sliced traj
    tsl = traj[10:80:2]
    for x in tsl:
        pass
    for x in tsl.copy():
        pass

    # repeat iter
    for i in range(2):
        cnt = 0
        for st in traj:
            cnt += 1
        assert cnt == nstep, "%i, %i" %(cnt, nstep)    
    
    # copy
    traj2 = traj.copy()
    for name in traj.attr_lst:
        val = getattr(traj,name)
        if val is not None and not (isinstance(val, types.IntType) or \
            isinstance(val, types.FloatType)):
            val2 = getattr(traj2,name)
            print "test copy:", name, type(val), type(val2)
            assert id(val2) != id(val)
            assert_all_types_equal(val2, val)
    assert_dict_with_all_types_equal(traj.__dict__, traj2.__dict__,
                                     keys=traj.attr_lst)
Beispiel #8
0
def test_traj():
    natoms = 10
    nstep = 100
    cell = rand(nstep, 3, 3)
    stress = rand(nstep, 3, 3)
    forces = rand(nstep, natoms, 3)
    etot = rand(nstep)
    cryst_const = crys.cell2cc3d(cell, axis=0)
    coords_frac = rand(nstep, natoms, 3)
    coords = crys.coord_trans3d(coords=coords_frac,
                                old=cell,
                                new=num.extend_array(np.identity(3),
                                                     nstep,
                                                     axis=0),
                                axis=1,
                                timeaxis=0)
    assert cryst_const.shape == (nstep, 6)
    assert coords.shape == (nstep, natoms, 3)
    symbols = ['H'] * natoms

    # automatically calculated:
    #   coords
    #   cell
    #   pressure
    #   velocity (from coords)
    #   temperature (from ekin)
    #   ekin (from velocity)
    traj = Trajectory(
        coords_frac=coords_frac,
        cell=cell,
        symbols=symbols,
        forces=forces,
        stress=stress,
        etot=etot,
        timestep=1,
    )
    # Test if all getters work.
    for name in traj.attr_lst:
        print("test if getters work:", name)
        traj.try_set_attr(name)
        assert getattr(traj, name) is not None, "attr None: %s" % name
        assert eval('traj.get_%s()' %
                    name) is not None, "getter returns None: %s" % name
        print("test if getters work:", name, "... ok")
    aaae(coords_frac, traj.coords_frac)
    aaae(coords, traj.coords)
    aaae(cryst_const, traj.cryst_const)
    aaae(np.trace(stress, axis1=1, axis2=2) / 3.0, traj.pressure)
    assert traj.coords.shape == (nstep, natoms, 3)
    assert traj.cell.shape == (nstep, 3, 3)
    assert traj.velocity.shape == (nstep, natoms, 3)
    assert traj.temperature.shape == (nstep, )
    assert traj.ekin.shape == (nstep, )
    assert traj.nstep == nstep
    assert traj.natoms == natoms

    traj = Trajectory(coords_frac=coords_frac, symbols=symbols, cell=cell)
    aaae(coords, traj.coords)

    # Cell calculated from cryst_const has defined orientation in space which may be
    # different from the original `cell`, but the volume and underlying cryst_const
    # must be the same.
    traj = Trajectory(coords_frac=coords_frac,
                      symbols=symbols,
                      cryst_const=cryst_const)
    np.testing.assert_almost_equal(crys.volume_cell3d(cell),
                                   crys.volume_cell3d(traj.cell))
    aaae(cryst_const, crys.cell2cc3d(traj.cell))

    # extend arrays
    cell2d = rand(3, 3)
    cc2d = crys.cell2cc(cell2d)
    traj = Trajectory(coords_frac=coords_frac, cell=cell2d, symbols=symbols)
    assert traj.cell.shape == (nstep, 3, 3)
    assert traj.cryst_const.shape == (nstep, 6)
    for ii in range(traj.nstep):
        assert (traj.cell[ii, ...] == cell2d).all()
        assert (traj.cryst_const[ii, :] == cc2d).all()

    traj = Trajectory(coords_frac=coords_frac,
                      cryst_const=cc2d,
                      symbols=symbols)
    assert traj.cell.shape == (nstep, 3, 3)
    assert traj.cryst_const.shape == (nstep, 6)
    for ii in range(traj.nstep):
        assert (traj.cryst_const[ii, :] == cc2d).all()

    # units
    traj = Trajectory(coords_frac=coords_frac,
                      cell=cell,
                      symbols=symbols,
                      stress=stress,
                      forces=forces,
                      units={
                          'length': 2,
                          'forces': 3,
                          'stress': 4
                      })
    aaae(2 * coords, traj.coords)
    aaae(3 * forces, traj.forces)
    aaae(4 * stress, traj.stress)

    # iterate, check if Structures are complete
    traj = Trajectory(coords=coords,
                      symbols=symbols,
                      cell=cell,
                      forces=forces,
                      stress=stress,
                      etot=etot,
                      timestep=1.0)
    for struct in traj:
        assert struct.is_struct, "st is not Structure"
        assert not struct.is_traj, "st is Trajectory"
        assert_attrs_not_none(struct)
    struct = traj[0]
    for attr_name in traj.attr_lst:
        if attr_name in struct.attrs_only_traj:
            msg = "tr[0] %s is not None" % attr_name
            assert getattr(struct, attr_name) is None, msg
        else:
            msg = "tr[0] %s is None" % attr_name
            assert getattr(struct, attr_name) is not None, msg

    # slices, return traj
    keys = traj.attr_lst[:]
    tsl = traj[10:80:2]
    assert tsl.nstep == traj.nstep / 2 - 15
    assert_attrs_not_none(tsl, attr_lst=keys)
    tsl = traj[slice(10, 80, 2)]
    assert tsl.nstep == traj.nstep / 2 - 15
    assert_attrs_not_none(tsl, attr_lst=keys)
    tsl = traj[np.s_[10:80:2]]
    assert tsl.nstep == traj.nstep / 2 - 15
    assert_attrs_not_none(tsl, attr_lst=keys)
    assert tsl.is_traj

    # iteration over sliced traj
    tsl = traj[10:80:2]
    for x in tsl:
        pass
    for x in tsl.copy():
        pass

    # repeat iter
    for i in range(2):
        cnt = 0
        for st in traj:
            cnt += 1
        assert cnt == nstep, "%i, %i" % (cnt, nstep)

    # copy
    traj2 = traj.copy()
    for name in traj.attr_lst:
        val = getattr(traj, name)
        if val is not None and not (isinstance(val, int) or \
            isinstance(val, float)):
            val2 = getattr(traj2, name)
            print("test copy:", name, type(val), type(val2))
            assert id(val2) != id(val)
            assert_all_types_equal(val2, val)
    assert_dict_with_all_types_equal(traj.__dict__,
                                     traj2.__dict__,
                                     keys=traj.attr_lst)