def test_morse_fit():
import numpy as np
from testing import value_eq
from unit_converter import convert
from numerics import morse
from numerics import morse_rDw_fit,morse_fit,morse_fit_fine
r_ref,D_ref,w_ref = 1.620,6.87,1009.18
r_ref_A = r_ref
p = morse_rDw_fit(r_ref,D_ref,w_ref,'Ti','O',Dunit='eV')
r_ref = convert(r_ref,'A','B')
rfine = np.linspace(0.8*r_ref,1.2*r_ref,100)
Efine = morse(p,rfine)
pf = morse_fit(rfine,Efine,p)
pref = tuple(np.array(p,dtype=float))
pf = tuple(np.array(pf,dtype=float))
assert(value_eq(pf,pref))
pf,Ef = morse_fit_fine(rfine,Efine,p,rfine,both=True)
pf = tuple(np.array(pf,dtype=float))
assert(value_eq(pf,pref))
assert(value_eq(Ef,Efine))
def translate_and_check(g, shift):
gt = g.copy()
gt.translate(shift)
shift = np.array(shift).ravel()
assert (value_eq(gt.origin - g.origin, shift))
dpoints = gt.points - g.points
for dp in dpoints:
assert (value_eq(dp, shift))
def struct_same(s1, s2, axes=True):
same = True
same &= value_eq(s1.elem, s2.elem)
same &= value_eq(s1.pos, s2.pos)
if axes:
same &= value_eq(s1.axes, s2.axes)
#end if
return same
def test_nearest_neighbors():
import numpy as np
from testing import value_eq
from numerics import nearest_neighbors
points = [
[0,0,0],
[1,0,0],
[0,1,0],
[1,1,0],
[0,0,1],
[1,0,1],
[0,1,1],
[1,1,1],
]
points = np.array(points,dtype=float)
plow = points[:4]
phigh = points[4:]
d0 = 0.0
d1 = 1.0
d2 = np.sqrt(2.)
d3 = np.sqrt(3.)
nn_ref = [[0,1,2],
[1,0,3],
[2,0,3],
[3,1,2]]
nn_ref = np.array(nn_ref,dtype=int)
dist_ref = [[d1,d2,d2],
[d1,d2,d2],
[d1,d2,d2],
[d1,d2,d2]]
dist_ref = np.array(dist_ref,dtype=float)
def check_nn(nn):
for n,nr in zip(nn,nn_ref):
assert(n[0]==nr[0])
assert(set(n[1:])==set(nr[1:]))
#end for
#end def check_nn
nn = nearest_neighbors(3,plow,phigh,slow=True)
check_nn(nn)
nn,dist = nearest_neighbors(3,plow,phigh,return_distances=True,slow=True)
check_nn(nn)
assert(value_eq(dist,dist_ref))
if scipy_available:
nn = nearest_neighbors(3,plow,phigh)
check_nn(nn)
nn,dist = nearest_neighbors(3,plow,phigh,return_distances=True)
check_nn(nn)
assert(value_eq(dist,dist_ref))
def test_periodic_table():
from testing import value_eq
from periodic_table import pt
elements = set('''
H He
Li Be B C N O F Ne
Na Mg Al Si P S Cl Ar
K Ca Sc Ti V Cr Mn Fe Co Ni Cu Zn Ga Ge As Se Br Kr
Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I Xe
Cs Ba La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt Au Hg Tl Pb Bi Po At Rn
Fr Ra Ac Th Pa U Np Pu Am Cm Bk Cf Es Fm Md No Lr
'''.split())
atomic_numbers = set(range(1, len(elements) + 1))
missing = elements - set(pt.keys())
assert (len(missing) == 0)
missing = elements - set(pt.elements.keys())
assert (len(missing) == 0)
missing = atomic_numbers - set(pt.simple_elements.keys())
assert (len(missing) == 0)
fields = '''
atomic_weight
atomic_radius
nuclear_charge
electron_affinity
ionization_energy
ionic_radius
thermal_cond
melting_point
boiling_point
'''.split()
for e in elements:
elem = pt.elements[e]
assert (id(elem) == id(pt[e]))
selem = pt.simple_elements[elem.atomic_number]
for f in fields:
assert (value_eq(selem[f], elem[f].orig))
#end for
#end for
C = pt.C
assert (C.atomic_number == 6)
assert (C.symbol == 'C')
assert (value_eq(C.atomic_radius.pm, 77.2))
assert (value_eq(C.atomic_weight.amu, 12.011))
assert (value_eq(C.boiling_point.degC, 4827.0))
assert (value_eq(C.electron_affinity.kJ_mol, 121.9))
assert (value_eq(C.ionic_radius.pm, 260.0))
assert (value_eq(C.ionization_energy.eV, 11.26))
assert (value_eq(C.melting_point.degC, 3550.0))
assert (value_eq(C.nuclear_charge.e, 3.25))
assert (value_eq(C.thermal_cond.W_mK, 1960.0))
def test_ttest():
import numpy as np
from testing import value_eq
from numerics import ttest
p = ttest(0.,1.,100,0.,1.,100)
assert(value_eq(float(p),1.0))
p = ttest(0.,1.,10000,1.,1.,10000)
assert(value_eq(float(p),0.479508361523))
def test_parallelotope_grid_points():
import numpy as np
from testing import value_eq
from grid_functions import unit_grid_points
from grid_functions import parallelotope_grid_points
axes_dim = {
1: [[1]],
2: [[1, 1], [0, 1]],
3: [[1, 1, 1], [0, 1, 1], [0, 0, 1]],
}
shapes_dim = {
1: (5, ),
2: (5, 3),
3: (5, 3, 7),
}
for d in range(1, 4):
axes = axes_dim[d]
shape = shapes_dim[d]
for c in (False, True):
for e in (False, True):
ep = d * [e]
u = unit_grid_points(shape=shape, centered=c, endpoint=ep)
ref = np.dot(u, axes)
p = parallelotope_grid_points(axes=axes,
shape=shape,
centered=c,
endpoint=ep)
assert (value_eq(p, ref))
cells = np.array(shape, dtype=int)
if not c:
cells -= np.array(ep, dtype=int)
#end if
p = parallelotope_grid_points(axes=axes,
cells=cells,
centered=c,
endpoint=ep)
assert (value_eq(p, ref))
dr = 1.0 / cells
for i in range(len(dr)):
dr[i] *= np.linalg.norm(axes[i])
#end for
p = parallelotope_grid_points(axes=axes,
dr=dr,
centered=c,
endpoint=ep)
assert (value_eq(p, ref))
def test_simstats():
import numpy as np
from testing import value_eq
from numerics import simstats
m,v,e,k = simstats(rstream)
m_ref = 0.507154277182
v_ref = 0.0840257344388
e_ref = 0.00949486225214
k_ref = 1.07291426596
assert(value_eq(float(m),m_ref))
assert(value_eq(float(v),v_ref))
assert(value_eq(float(e),e_ref))
assert(value_eq(float(k),k_ref))
m_ref = np.array(10*[m_ref])
v_ref = np.array(10*[v_ref])
e_ref = np.array(10*[e_ref])
k_ref = np.array(10*[k_ref])
m,v,e,k = simstats(rstream_wide)
assert(value_eq(m,m_ref))
assert(value_eq(v,v_ref))
assert(value_eq(e,e_ref))
assert(value_eq(k,k_ref))
def test_incorporate_result():
from generic import obj
tpath = testing.setup_unit_test_output_directory('pwscf_simulation','test_incorporate_result',**pseudo_inputs)
sim = get_pwscf_sim('scf')
sim_start = sim.to_obj().copy()
assert(object_eq(sim.to_obj(),sim_start))
# charge density
result = obj(
locdir = sim.locdir,
)
sim.incorporate_result('charge_density',result,None)
assert(object_eq(sim.to_obj(),sim_start))
# restart
sim.incorporate_result('restart',result,None)
c = sim.input.control
assert(c.restart_mode=='restart')
del c.restart_mode
assert(object_eq(sim.to_obj(),sim_start))
# structure
altered_structure = sim.system.structure.copy()
altered_structure.pos += 0.1
result = obj(
structure = altered_structure,
)
sim.incorporate_result('structure',result,None)
sim_ref = sim_start.copy()
pos_ref = sim_ref.system.structure.delete('pos')+0.1
sim_ref.input.atomic_positions.delete('positions')
pos = sim.system.structure.delete('pos')
apos = sim.input.atomic_positions.delete('positions')
assert(value_eq(pos,pos_ref))
assert(value_eq(apos,pos_ref))
assert(object_eq(sim.to_obj(),sim_ref))
clear_all_sims()
restore_nexus()
def test_jackknife():
from testing import value_eq
from numerics import jackknife
def value(v):
return v
#end def value
jm_ref = np.array(10*[0.50715428],dtype=float)
je_ref = np.array(10*[0.00917114],dtype=float)
jm,je = jackknife(rstream_wide.T,value)
assert(value_eq(jm,jm_ref))
assert(value_eq(je,je_ref))
def test_ndgrid():
import numpy as np
from testing import value_eq
from numerics import ndgrid
x = [0,1,2.]
y = [3,4.,5,6]
z = [7,8,9,10,11.]
points = np.zeros((3,len(x)*len(y)*len(z)),dtype=float)
n = 0
for xv in x:
for yv in y:
for zv in z:
points[:,n] = xv,yv,zv
n += 1
#end for
#end for
#end for
points = np.array(points)
points.shape = 3,len(x),len(y),len(z)
points = points
grid = ndgrid(x,y,z)
assert(value_eq(grid,points))
def shift_and_test_inside(g, p, upoints, d, sign):
us = upoints.copy()
us[:, d] += ushift
ps = g.points_from_unit(us)
ps_ref = ps.copy()
inside = g.inside(ps)
assert (value_eq(ps, ps_ref))
if isinstance(g, SpheroidSurfaceGrid):
assert (inside.all())
elif isinstance(g, SpheroidGrid):
if d == 0:
assert (not inside.any()) # radial coord
else:
assert (inside.all()) # angular coords
#end if
elif isinstance(g, ParallelotopeGrid):
if g.bconds[d] == 'o':
assert (not inside.any())
elif g.bconds[d] == 'p':
assert (inside.all())
else:
assert (1 == 0)
#end if
else:
assert (1 == 0)
def test_textfile():
from fileio import TextFile
files = get_files()
# test empty initialization
empty = TextFile()
# test read
f = TextFile(files['scf.in'])
assert(len(f.read())==1225)
assert(len(f.lines())==55)
assert(len(f.tokens())==125)
assert(f.readline()=='&CONTROL\n')
assert(f.readline()==" calculation = 'scf'\n")
assert(f.readline('celldm')=='celldm(1) = 1.0\n')
assert(f.readtokens('ecutwfc')==['ecutwfc', '=', '272'])
val = f.readtokensf('CELL_PARAMETERS',float,float,float)
ref = [28.34589199, 0.0, 0.0]
assert(value_eq(val,ref))
f.close()
def test_get_output_files():
import os
tpath = testing.setup_unit_test_output_directory('vasp_simulation',
'test_get_output_files',
**pseudo_inputs)
sim = setup_vasp_sim(tpath)
vfiles = 'INCAR KPOINTS POSCAR CONTCAR OUTCAR'.split()
for vfile in vfiles:
f = open(os.path.join(tpath, vfile), 'w')
f.write('')
f.close()
#end for
files = sim.get_output_files()
assert (value_eq(files, vfiles))
for vfile in vfiles:
assert (os.path.exists(
os.path.join(tpath, sim.identifier + '.' + vfile)))
#end for
clear_all_sims()
restore_nexus()
def test_grid_cell_indices():
import numpy as np
from testing import value_eq, object_eq
from grid_functions import ParallelotopeGrid
from grid_functions import SpheroidGrid
from grid_functions import SpheroidSurfaceGrid
p = ParallelotopeGrid(
cells=(10, 10),
axes=[[1, 0, 0], [1, 1, 1]],
)
pc = ParallelotopeGrid(cells=(10, 10),
axes=[[1, 0, 0], [1, 1, 1]],
centered=True)
s = SpheroidGrid(
cells=(10, 10),
axes=[[1, 0, 0], [1, 1, 1]],
)
sc = SpheroidGrid(
cells=(10, 10),
axes=[[1, 0, 0], [1, 1, 1]],
centered=True,
)
c = SpheroidSurfaceGrid(
cells=(10, 10),
axes=[[1, 0, 0], [1, 1, 0], [1, 1, 1]],
)
cc = SpheroidSurfaceGrid(
cells=(10, 10),
axes=[[1, 0, 0], [1, 1, 0], [1, 1, 1]],
centered=True,
)
imap = np.arange(100, dtype=int)
assert ((pc.cell_indices() == imap).all())
assert ((p.cell_indices(pc.r) == imap).all())
assert ((sc.cell_indices() == imap).all())
assert ((s.cell_indices(sc.r) == imap).all())
assert ((cc.cell_indices() == imap).all())
assert ((c.cell_indices(cc.r) == imap).all())
indices = {
1: np.arange(5, dtype=int),
2: np.arange(5**2, dtype=int),
3: np.arange(5**3, dtype=int),
}
grids = get_grids()
props = get_props()
for name in sorted(grids.keys()):
p = props[name]
if p.centered:
g = grids[name].copy()
gref = g.copy()
assert (value_eq(g.cell_indices(), indices[p.grid_dim]))
assert (object_eq(g, gref))
def test_grid_radius():
from testing import value_eq
from grid_functions import SpheroidGrid, SpheroidSurfaceGrid
grids = get_grids()
for name in sorted(grids.keys()):
g = grids[name]
if isinstance(g, (SpheroidGrid, SpheroidSurfaceGrid)):
if g.isotropic:
assert (value_eq(g.radius(), 1.0))
def test_change_units():
from physical_system import generate_physical_system
sys = generate_physical_system(
units='A',
axes=[[3.57, 0.00, 0.00], [0.00, 3.57, 0.00], [0.00, 0.00, 3.57]],
elem=8 * ['C'],
posu=[[0.00, 0.00, 0.00], [0.25, 0.25, 0.25], [0.00, 0.50, 0.50],
[0.25, 0.75, 0.75], [0.50, 0.00, 0.50], [0.75, 0.25, 0.75],
[0.50, 0.50, 0.00], [0.75, 0.75, 0.25]],
C=4,
)
s = sys.structure
assert (value_eq(s.pos[-1], np.array([2.6775, 2.6775, 0.8925])))
sys.change_units('B')
assert (value_eq(s.pos[-1], np.array([5.05974172, 5.05974172,
1.68658057])))
def test_eos():
import numpy as np
from testing import value_eq
from unit_converter import convert
from numerics import eos_fit,eos_eval,eos_param
data = np.array([
[0.875, -83.31851261],
[0.900, -83.38085214],
[0.925, -83.42172843],
[0.950, -83.44502216],
[0.975, -83.45476035],
[1.025, -83.44564229],
[1.050, -83.43127254],
[1.000, -83.45412846],
[1.100, -83.39070714],
[1.125, -83.36663810],
])
a = 5.539 # lattice constant
V = (a*data[:,0])**3
E = convert(data[:,1],'Ry','eV')
# done originally to get params below
#pf = eos_fit(V,E,'vinet')
Einf = -1.13547294e+03
V0 = 1.62708941e+02
B0 = 1.34467867e-01
Bp0 = 4.55846963e+00
pf = Einf,V0,B0,Bp0
Ef = eos_eval(pf,V,'vinet')
assert(value_eq(Ef,E,atol=4e-3))
assert(value_eq(float(eos_param(pf,'Einf','vinet')),Einf))
assert(value_eq(float(eos_param(pf,'V','vinet')),V0))
assert(value_eq(float(eos_param(pf,'B','vinet')),B0))
assert(value_eq(float(eos_param(pf,'Bp','vinet')),Bp0))
def test_simplestats():
import numpy as np
from testing import value_eq
from numerics import simplestats
m,e = simplestats(rstream)
m_ref = 0.507154277182
e_ref = 0.00916655521114
assert(value_eq(float(m),m_ref))
assert(value_eq(float(e),e_ref))
m_ref = np.array(10*[m_ref])
e_ref = np.array(10*[e_ref])
m,e = simplestats(rstream_wide)
assert(value_eq(m,m_ref))
assert(value_eq(e,e_ref))
def test_grid_cell_volumes():
from testing import value_eq
from grid_functions import SpheroidSurfaceGrid
grids = get_grids()
for name in sorted(grids.keys()):
g = grids[name]
if not isinstance(g, SpheroidSurfaceGrid) or g.isotropic:
assert (value_eq(g.volume(), g.cell_volumes().sum()))
else:
None # not supported
def check(r=None, theta=None, phi=None):
if r is not None:
r = unique(r)
dr = unique(r[1:] - r[:-1])
assert (len(r) == n)
assert (len(dr) == 1)
assert (value_eq(dr[0], 1.0 / n))
#end if
if theta is not None:
t = unique(theta)
dt = unique(t[1:] - t[:-1])
assert (len(t) == n)
assert (len(dt) == 1)
assert (value_eq(dt[0], np.pi / n))
#end if
if phi is not None:
p = unique(phi)
dp = unique(p[1:] - p[:-1])
assert (len(p) == n)
assert (len(dp) == 1)
assert (value_eq(dp[0], 2 * np.pi / n))
def test_grid_volume():
import numpy as np
from testing import value_eq
from grid_functions import ParallelotopeGrid
from grid_functions import SpheroidGrid
from grid_functions import SpheroidSurfaceGrid
grids = get_grids()
props = get_props()
for name in sorted(grids.keys()):
g = grids[name]
p = props[name]
gd, sd = g.grid_dim, g.space_dim
if isinstance(g, ParallelotopeGrid):
vratio = g.volume() / g.axes_volume()
assert (value_eq(vratio, 1.0))
elif isinstance(g, SpheroidGrid):
volume = g.volume()
if not g.isotropic:
vratio = volume / g.axes_volume()
if gd == 2:
assert (value_eq(vratio, np.pi * r**2))
elif gd == 3:
assert (value_eq(vratio, 4 * np.pi / 3 * r**3))
else:
assert (1 == 0)
#end if
else:
r = g.radius()
if gd == 2:
assert (value_eq(volume, np.pi * r**2))
elif gd == 3:
assert (value_eq(volume, 4 * np.pi / 3 * r**3))
else:
assert (1 == 0)
#end if
elif isinstance(g, SpheroidSurfaceGrid):
if g.isotropic:
volume = g.volume()
r = g.radius()
if gd == 1:
assert (value_eq(volume, 2 * np.pi * r))
elif gd == 2:
assert (value_eq(volume, 4 * np.pi * r**2))
else:
assert (1 == 0)
#end if
else:
None # not supported
#end if
else:
assert (1 == 0)
def test_pyscf_to_afqmc_input_init():
from qmcpack_converters import PyscfToAfqmcInput
from qmcpack_converters import generate_pyscf_to_afqmc_input
# empty init
pi = PyscfToAfqmcInput()
assert (pi.is_valid())
assert (set(pi.keys()) == set(PyscfToAfqmcInput.input_defaults.keys()))
for v in pi:
assert (v is None or v == False or v == 'pyscf_to_afqmc.py')
#end for
pi2 = generate_pyscf_to_afqmc_input()
assert (pi2.is_valid())
assert (object_eq(pi2, pi))
# simple init
pi = generate_pyscf_to_afqmc_input(
input='scf.chk',
output='afqmc.h5',
cholesky_threshold=1e-5,
verbose=True,
)
assert (pi.is_valid())
assert (pi.input == 'scf.chk')
assert (pi.output == 'afqmc.h5')
assert (value_eq(pi.cholesky_threshold, 1e-5))
assert (value_eq(pi.verbose, True))
pi2 = generate_pyscf_to_afqmc_input(
i='scf.chk',
o='afqmc.h5',
t=1e-5,
v=True,
)
assert (pi2.is_valid())
assert (object_eq(pi2, pi))
def test_string2val():
import numpy as np
from testing import value_eq
from superstring import string2val
v = string2val('False')
assert(isinstance(v,bool))
assert(v==False)
v = string2val('True')
assert(isinstance(v,bool))
assert(v==True)
v = string2val('43')
assert(isinstance(v,int))
assert(v==43)
v = string2val('3.14')
assert(isinstance(v,float))
assert(np.abs(v-3.14)<1e-6)
v = string2val('1 2 3 4',delim=' ')
assert(isinstance(v,np.ndarray))
assert(value_eq(v,np.array([1,2,3,4],dtype=int)))
v = string2val('1, 2, 3, 4',delim=',')
assert(isinstance(v,np.ndarray))
assert(value_eq(v,np.array([1,2,3,4],dtype=int)))
v = string2val('1. 2 3 4',delim=' ')
assert(isinstance(v,np.ndarray))
assert(value_eq(v,np.array([1,2,3,4],dtype=float)))
v = string2val('1., 2, 3, 4',delim=',')
assert(isinstance(v,np.ndarray))
assert(value_eq(v,np.array([1,2,3,4],dtype=float)))
def test_twist_average_analysis():
import os
from generic import obj
from qmcpack_analyzer import QmcpackAnalyzer
tpath = testing.setup_unit_test_output_directory(
test='qmcpack_analyzer',
subtest='test_twist_average_analysis',
file_sets=['diamond_twist'],
)
# test analysis of twist averaged vmc data
infile = os.path.join(tpath, 'diamond_twist/vmc/vmc.in')
qa = QmcpackAnalyzer(infile, analyze=True, equilibration=5)
qa_keys = 'info wavefunction vmc qmc bundled_analyzers'.split()
assert (set(qa.keys()) == set(qa_keys))
ba = qa.bundled_analyzers
ba_keys = [0, 1, 2, 3]
assert (set(ba.keys()) == set(ba_keys))
for n in ba_keys:
assert (isinstance(ba[n], QmcpackAnalyzer))
#end for
qa2 = ba[2]
qa2_keys = 'info wavefunction vmc qmc'.split()
assert (set(qa2.keys()) == set(qa2_keys))
le_twists = obj()
for n in ba_keys:
le_twists[n] = ba[n].qmc[0].scalars.LocalEnergy.mean
#end for
le_twists_ref = obj({
0: -10.477644724210526,
1: -11.54064069741053,
2: -11.547046178357895,
3: -11.809361818642103,
})
assert (object_eq(le_twists, le_twists_ref))
le_avg = qa.qmc[0].scalars.LocalEnergy.mean
le_avg_ref = -11.343673354655264
assert (value_eq(le_avg, le_avg_ref))
def test_density_analysis():
import os
from numpy import array
from generic import obj
from qmcpack_analyzer import QmcpackAnalyzer
tpath = testing.setup_unit_test_output_directory(
test='qmcpack_analyzer',
subtest='test_density_analysis',
file_sets=['diamond_gamma'],
)
infile = os.path.join(tpath, 'diamond_gamma/dmc/dmc.in.xml')
qa = QmcpackAnalyzer(infile, analyze=True, equilibration=5)
qmc = qa.qmc[0]
qmc_keys = 'info data scalars scalars_hdf SpinDensity'.split()
assert (set(qmc.keys()) == set(qmc_keys))
sd = qmc.SpinDensity
sd_keys = 'info method_info data u d'.split()
assert (set(sd.keys()) == set(sd_keys))
d_keys = 'mean error'.split()
assert (set(sd.u.keys()) == set(d_keys))
assert (set(sd.d.keys()) == set(d_keys))
d_mean = sd.u.mean + sd.d.mean
d_mean_ref = array(
[[[0.72833333, 0.604, 0.514], [0.63666667, 0.19533333, 0.19683333],
[0.51166667, 0.19183333, 0.4175]],
[[0.6065, 0.19533333, 0.19], [0.19066667, 0.052, 0.129],
[0.18783333, 0.13433333, 0.10483333]],
[[0.50633333, 0.19633333, 0.42483333],
[0.1775, 0.12966667, 0.09983333], [0.417, 0.106, 0.15583333]]],
dtype=float)
assert (d_mean.shape == (3, 3, 3))
assert (value_eq(d_mean, d_mean_ref))
def check_settings_core_noncore():
nckeys_check = set([
'command_line', 'debug', 'dependent_modes', 'emulate',
'file_locations', 'generate_only', 'graph_sims', 'indent',
'load_images', 'local_directory', 'mode', 'modes', 'monitor',
'primary_modes', 'progress_tty', 'pseudo_dir', 'pseudopotentials',
'remote_directory', 'results', 'runs', 'skip_submit', 'sleep',
'stages', 'stages_set', 'status', 'status_modes', 'status_only',
'trace', 'verbose'
])
nnckeys_check = set(
['basis_dir', 'basissets', 'pseudo_dir', 'pseudopotentials'])
setkeys_check = set([
'command_line', 'basis_dir', 'basissets', 'debug',
'dependent_modes', 'emulate', 'file_locations', 'generate_only',
'graph_sims', 'indent', 'load_images', 'local_directory', 'mode',
'modes', 'monitor', 'primary_modes', 'progress_tty', 'pseudo_dir',
'pseudopotentials', 'remote_directory', 'results', 'runs',
'skip_submit', 'sleep', 'stages', 'stages_set', 'status',
'status_modes', 'status_only', 'trace', 'verbose'
])
setkeys_allowed = setkeys_check | Settings.allowed_vars
nckeys = set(nexus_core.keys())
nnckeys = set(nexus_noncore.keys())
setkeys = set(settings.keys())
assert (nckeys == nckeys_check)
assert (nnckeys == nnckeys_check)
assert (setkeys >= setkeys_check)
assert (setkeys <= setkeys_allowed)
pairs = [(settings, nexus_core), (settings, nexus_noncore),
(nexus_core, nexus_noncore)]
for o1, o2 in pairs:
shared_keys = set(o1.keys()) & set(o2.keys())
for k in shared_keys:
v1 = o1[k]
v2 = o2[k]
if isinstance(v1, obj):
assert (object_eq(v1, v2))
else:
assert (value_eq(v1, v2))
def test_convert_scalar_to_all():
from testing import value_eq
from unit_converter import UnitConverter
eV_to = {
'J': 1.60217646e-19,
'Ha': 0.03674932439858279,
'Ry': 0.07349864879716558,
'eV': 1.0,
'kcal_mol': 23.0605419446755,
'kJ_mol': 96.48533350089092,
'K': 11604.505934630948,
'degC': 11331.355934630948,
'degF': 20428.440682335706,
}
v = UnitConverter.convert_scalar_to_all('eV', 1.0)
for unit in eV_to.keys():
assert (value_eq(v[unit], eV_to[unit]))
def test_grid_axes_volume():
import numpy as np
from testing import value_eq
grids = get_grids()
props = get_props()
for name in sorted(grids.keys()):
g = grids[name]
p = props[name]
gd, sd = g.grid_dim, g.space_dim
gsd = gd, sd
embedded = gd != sd
axvol = g.axes_volume()
if not g.surface and not embedded:
assert (value_eq(axvol, 1.0))
elif g.surface:
if gsd == (1, 3) and p.sheared:
assert (value_eq(axvol, np.sqrt(2.0)))
else:
assert (value_eq(axvol, 1.0))
#end if
else: # embedded
if gsd == (1, 2):
assert (value_eq(axvol, np.sqrt(2.0)))
elif gsd == (1, 3):
assert (value_eq(axvol, np.sqrt(3.0)))
elif gsd == (2, 3):
if p.sheared:
assert (value_eq(axvol, np.sqrt(2.0)))
else:
assert (value_eq(axvol, 1.0))
#end if
else:
assert (1 == 0)
def test_analyze():
import os
from numpy import array, ndarray
from generic import obj
from vasp_analyzer import VaspAnalyzer, VXML, VXMLcoll, OutcarData
tpath = testing.setup_unit_test_output_directory(
test='vasp_analyzer',
subtest='test_analyze',
file_sets=relax_files,
)
incar_path = os.path.join(tpath, 'relax.INCAR')
# empty init
va = VaspAnalyzer(incar_path)
va_ref = obj(info=obj(
incar_file='relax.INCAR',
neb=False,
outcar_file='relax.OUTCAR',
prefix='relax.',
xml=False,
xml_file='relax.vasprun.xml',
incar=obj(
ediff=1e-06,
ediffg=-0.01,
elmin=5,
ibrion=1,
istart=0,
nelect=130.0,
nsw=20,
prec='normal',
),
), )
del va.info.path
assert (object_eq(va, va_ref))
# full analysis
va = VaspAnalyzer(incar_path, xml=True, analyze=True)
del va.info.path
info = obj(
incar_file='relax.INCAR',
neb=False,
outcar_file='relax.OUTCAR',
prefix='relax.',
xml=True,
xml_file='relax.vasprun.xml',
incar=obj(
ediff=1e-06,
ediffg=-0.01,
elmin=5,
ibrion=1,
istart=0,
nelect=130.0,
nsw=20,
prec='normal',
),
)
assert (object_eq(va.info, info))
types = dict(
Efermi=float,
core_potential_radii=ndarray,
core_potentials=ndarray,
force=ndarray,
info=obj,
ion_steps=obj,
lattice_vectors=ndarray,
memory=obj,
position=ndarray,
pressure=float,
stress=obj,
stress_kb=obj,
time=obj,
total_drift=ndarray,
total_energy=float,
volume=float,
xmldata=VXML,
)
for name, type in types.items():
assert (name in va)
assert (isinstance(va[name], type))
#end for
simple_data = obj(
Efermi=-0.5064,
core_potential_radii=array([1.2059], dtype=float),
core_potentials=array([
-56.6601, -56.6601, -56.6601, -56.6601, -57.1969, -57.2036,
-57.5372, -57.1969, -56.9801, -56.9801, -56.9801, -56.9801,
-56.4963
],
dtype=float),
force=array(
[[0.132123, -0.132123, -0.009177
], [-0.132123, -0.132123, -0.009177],
[0.132123, 0.132123, -0.009177], [-0.132123, 0.132123, -0.009177],
[0., 0., 0.002104], [0., 0., -0.000878], [0., 0., 0.004689],
[0., 0., 0.002104], [-0.0019, 0.0019, 0.005077],
[0.0019, 0.0019, 0.005077], [-0.0019, -0.0019, 0.005077],
[0.0019, -0.0019, 0.005077], [0., 0., 0.008385]],
dtype=float),
lattice_vectors=array(
[[5.62024, 0., 0.], [0., 5.62024, 0.], [0., 0., 16.86072]],
dtype=float),
position=array(
[[1.40506, 1.40506, 1.98704], [4.21518, 1.40506, 1.98704],
[1.40506, 4.21518, 1.98704], [4.21518, 4.21518, 1.98704],
[0., 0., 3.88944], [0., 2.81012, 3.89432], [2.81012, 0., 3.95815],
[2.81012, 2.81012, 3.88944], [1.44092, 1.3692, 5.85353],
[4.17932, 1.3692, 5.85353], [1.44092, 4.25104, 5.85353],
[4.17932, 4.25104, 5.85353], [0., 2.81012, 7.49145]],
dtype=float),
pressure=-29.47,
total_drift=array([0., 0., 0.042555], dtype=float),
total_energy=-71.46392704,
volume=532.58,
)
for name, data in simple_data.items():
assert (value_eq(va[name], data))
#end for
memory = obj(
average=0.0,
maximum=58808.0,
)
assert (object_eq(va.memory, memory))
stress = obj(
xx=-12.73119,
xy=0.0,
yy=-12.73119,
yz=0.0,
zx=0.0,
zz=-3.92272,
)
assert (object_eq(va.stress, stress))
stress_kb = obj(
xx=-38.29957,
xy=0.0,
yy=-38.29957,
yz=0.0,
zx=0.0,
zz=-11.80082,
)
assert (object_eq(va.stress_kb, stress_kb))
time = obj(
cpu=229.665,
elapsed=245.015,
system=5.815,
user=223.85,
)
assert (object_eq(va.time, time))
assert (len(va.ion_steps) == 10)
for n in range(1, 11):
assert (n in va.ion_steps)
#end for
last_step = va.ion_steps[10]
assert (len(last_step) == 4)
for n in range(1, 4):
assert (n in last_step)
assert (isinstance(last_step[n], OutcarData))
#end for
last_data = obj(
Efermi=-0.5064,
core_potential_radii=array([1.2059], dtype=float),
core_potentials=array([
-56.6601, -56.6601, -56.6601, -56.6601, -57.1969, -57.2036,
-57.5372, -57.1969, -56.9801, -56.9801, -56.9801, -56.9801,
-56.4963
],
dtype=float),
force=array(
[[0.132123, -0.132123, -0.009177
], [-0.132123, -0.132123, -0.009177],
[0.132123, 0.132123, -0.009177], [-0.132123, 0.132123, -0.009177],
[0., 0., 0.002104], [0., 0., -0.000878], [0., 0., 0.004689],
[0., 0., 0.002104], [-0.0019, 0.0019, 0.005077],
[0.0019, 0.0019, 0.005077], [-0.0019, -0.0019, 0.005077],
[0.0019, -0.0019, 0.005077], [0., 0., 0.008385]],
dtype=float),
lattice_vectors=array(
[[5.62024, 0., 0.], [0., 5.62024, 0.], [0., 0., 16.86072]],
dtype=float),
position=array(
[[1.40506, 1.40506, 1.98704], [4.21518, 1.40506, 1.98704],
[1.40506, 4.21518, 1.98704], [4.21518, 4.21518, 1.98704],
[0., 0., 3.88944], [0., 2.81012, 3.89432], [2.81012, 0., 3.95815],
[2.81012, 2.81012, 3.88944], [1.44092, 1.3692, 5.85353],
[4.17932, 1.3692, 5.85353], [1.44092, 4.25104, 5.85353],
[4.17932, 4.25104, 5.85353], [0., 2.81012, 7.49145]],
dtype=float),
pressure=-29.47,
total_drift=array([0., 0., 0.042555], dtype=float),
total_energy=-71.46392704,
volume=532.58,
memory=obj(
average=0.0,
maximum=58808.0,
),
stress=obj(
xx=-12.73119,
xy=0.0,
yy=-12.73119,
yz=0.0,
zx=0.0,
zz=-3.92272,
),
stress_kb=obj(
xx=-38.29957,
xy=0.0,
yy=-38.29957,
yz=0.0,
zx=0.0,
zz=-11.80082,
),
time=obj(
cpu=229.665,
elapsed=245.015,
system=5.815,
user=223.85,
),
)
assert (object_eq(va.ion_steps[10][4], last_data))
vxml = va.xmldata
keys = '''
atominfo
calculation
finalpos
generator
incar
initialpos
kpoints
parameters
'''.split()
assert (set(vxml.modeling.keys()) == set(keys))
parameters = obj(
gga_compat=True,
i_constrained_m=0,
icorelevel=0,
lberry=False,
ldau=False,
dos=obj(
efermi=0.0,
emax=-10.0,
emin=10.0,
lorbit=False,
nedos=301,
rwigs=-1.0,
),
electronic=obj(
ediff=1e-06,
enaug=358.966,
enmax=230.283,
eref=0.0,
ialgo=38,
irestart=0,
iwavpr=11,
nbands=96,
nelect=130.0,
nmin=0,
nreboot=0,
prec='normal',
turbo=0,
electronic_convergence=obj(
enini=230.283,
nelm=60,
nelmdl=-5,
nelmin=2,
electronic_convergence_detail=obj(
deper=0.3,
ebreak=0.0,
ldiag=True,
lsubrot=True,
nrmm=4,
time=0.4,
weimin=0.001,
),
),
electronic_dipolcorrection=obj(
dipol=array([-100., -100., -100.], dtype=float),
efield=0.0,
epsilon=1.0,
idipol=0,
ldipol=False,
lmono=False,
),
electronic_exchange_correlation=obj(
lasph=False,
lmetagga=False,
),
electronic_mixer=obj(
amin=0.1,
amix=0.4,
amix_mag=1.6,
bmix=1.0,
bmix_mag=1.0,
electronic_mixer_details=obj(
imix=4,
inimix=1,
maxmix=-45,
mixpre=1,
mremove=5,
wc=100.0,
),
),
electronic_projectors=obj(
lmaxmix=2,
lmaxpaw=-100,
lreal=False,
nlspline=False,
ropt=0.0,
),
electronic_smearing=obj(
ismear=1,
kgamma=True,
kspacing=0.5,
sigma=0.2,
),
electronic_spin=obj(
ispin=1,
lnoncollinear=False,
lsorbit=False,
lspiral=False,
lzeroz=False,
magmom=array(
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
dtype=float),
nupdown=-1.0,
qspiral=array([0., 0., 0.], dtype=float),
saxis=array([0., 0., 1.], dtype=float),
),
electronic_startup=obj(
icharg=2,
iniwav=1,
istart=0,
),
),
electronic_exchange_correlation=obj(
aexx=0.0,
aggac=1.0,
aggax=1.0,
aldac=1.0,
aldax=1.0,
encut4o=-1.0,
evenonly=False,
exxoep=0,
fourorbit=0,
gga='--',
hfalpha=0.0,
hfscreen=0.0,
hfscreenc=0.0,
lfockaedft=False,
lhfcalc=False,
lhfone=False,
lmaxfock=0,
lmodelhf=False,
lrhfcalc=False,
lsymgrad=False,
lthomas=False,
mcalpha=0.0,
nbandsgwlow=0,
nkredx=1,
nkredy=1,
nkredz=1,
nmaxfockae=0,
oddonly=False,
precfock='',
shiftred=False,
voskown=0,
),
general=obj(
lcompat=False,
system=array(['unknown', 'system'], dtype=str),
),
grids=obj(
addgrid=False,
ngx=24,
ngxf=48,
ngy=24,
ngyf=48,
ngz=64,
ngzf=128,
),
ionic=obj(
ediffg=-0.01,
ibrion=1,
isif=2,
nfree=0,
nsw=20,
potim=0.5,
pstress=0.0,
scalee=1.0,
smass=-3.0,
),
ionic_md=obj(
apaco=16.0,
kblock=20,
nblock=1,
npaco=256,
tebeg=0.0001,
teend=0.0001,
),
linear_response_parameters=obj(
cshift=0.1,
deg_threshold=0.002,
kinter=0,
lepsilon=False,
lnabla=False,
lrpa=False,
lvel=False,
omegamax=-1.0,
),
miscellaneous=obj(
darwinr=0.0,
darwinv=1.0,
idiot=3,
lcorr=True,
lmusic=False,
pomass=195.08,
),
model_gw=obj(
model_alpha=1.0,
model_eps0=24.58067119,
model_gw=0,
),
orbital_magnetization=obj(
avecconst=array([0., 0., 0.], dtype=float),
lchimag=False,
lgauge=True,
lmagbloch=False,
lnicsall=True,
magatom=0,
magdipol=array([0., 0., 0.], dtype=float),
magpos=array([0., 0., 0.], dtype=float),
nucind=False,
orbitalmag=False,
),
performance=obj(
lasync=False,
lorbitalreal=False,
lplane=True,
lscaaware=False,
lscalapack=False,
lscalu=False,
nblk=-1,
npar=32,
nsim=4,
),
response_functions=obj(
antires=0,
cshift=-0.1,
dim=3,
encutgw=-2.0,
encutgwsoft=-2.0,
encutlf=-1.0,
evenonlygw=False,
ibse=0,
l2order=False,
ladder=False,
lfxc=False,
lfxceps=False,
lhartree=True,
lmaxmp2=-1,
lspectral=False,
ltcte=False,
ltete=False,
ltriplet=False,
lusew=False,
maxmem=1800,
nbandsgw=-1,
nbandso=-1,
nbandsv=-1,
nelm=1,
nkredlfx=1,
nkredlfy=1,
nkredlfz=1,
nomega=0,
nomegar=0,
oddonlygw=False,
omegagrid=0,
omegamax=-30.0,
omegatl=-200.0,
scissor=0.0,
selfenergy=False,
telescope=0,
),
symmetry=obj(
isym=2,
symprec=1e-05,
),
vdw_dft=obj(
luse_vdw=False,
param1=0.1234,
param2=1.0,
param3=0.0,
zab_vdw=-0.8491,
),
writing=obj(
lcharg=True,
lelf=False,
loptics=False,
lpard=False,
lvhar=False,
lvtot=False,
lwave=True,
nwrite=2,
stm=array([0., 0., 0., 0., 0., 0., 0.], dtype=float),
),
)
assert (object_eq(vxml.modeling.parameters, parameters))
