def to_given_vector(infile,specorder,a1new,a2new,a3new):
psys = NAPSystem(fname=infile,specorder=specorder)
psys.assign_pbc()
psys.a1 = psys.a1 *psys.alc
psys.a2 = psys.a2 *psys.alc
psys.a3 = psys.a3 *psys.alc
psys.alc = 1.0
print('a1 = ',psys.a1)
print('a2 = ',psys.a2)
print('a3 = ',psys.a3)
pos = psys.get_real_positions()
spos = psys.get_scaled_positions()
for i in range(min(len(psys.atoms),10)):
a = psys.atoms[i]
print('{0:5d} {1:s}'.format(a.id,a.symbol)
+' {0:12.5f} {1:12.5f} {2:12.5f}'.format(spos[i,0],
spos[i,1],
spos[i,2])
+' {0:12.5f} {1:12.5f} {2:12.5f}'.format(pos[i,0],
pos[i,1],
pos[i,2]))
# print(psys.get_scaled_positions())
# print(psys.get_real_positions())
# sa1new = np.zeros(3,dtype=float)
# sa2new = np.zeros(3,dtype=float)
# sa3new = np.zeros(3,dtype=float)
#tmp = raw_input('Input new a1 vector: ')
#a1new[:] = [ float(x) for x in tmp.split(',') ]
# sa1new[:] = [ 0.5, 0.5, 0.0]
#tmp = raw_input('Input new a2 vector: ')
#a2new[:] = [ float(x) for x in tmp.split(',') ]
# sa2new[:] = [ 0.0, 1.0, 0.0 ]
#tmp = raw_input('Input new a3 vector: ')
#a3new[:] = [ float(x) for x in tmp.split(',') ]
# sa3new[:] = [ 0.5, 0.5, 1.0 ]
hmat = psys.get_hmat()
a1new = np.dot(hmat,sa1new)
a2new = np.dot(hmat,sa2new)
a3new = np.dot(hmat,sa3new)
print('new a1 in hmat_orig =',sa1new)
print('new a2 in hmat_orig =',sa2new)
print('new a3 in hmat_orig =',sa3new)
print('new a1 =',a1new)
print('new a2 =',a2new)
print('new a3 =',a3new)
psnew = NAPSystem(specorder=specorder)
psnew.set_lattice(psys.alc,a1new,a2new,a3new)
# Expand the original system for the search of atoms to be included
# in the new system.
# First, compute how much we have to expand the original system
hi = np.linalg.inv(hmat)
icsa1new = [0,0,0]
icsa2new = [0,0,0]
icsa3new = [0,0,0]
for i in range(3):
if sa1new[i] < 0.0:
icsa1new[i] = int(sa1new[i]-1.0)
else:
icsa1new[i] = int(sa1new[i]+1.0)
if sa2new[i] < 0.0:
icsa2new[i] = int(sa2new[i]-1.0)
else:
icsa2new[i] = int(sa2new[i]+1.0)
if sa3new[i] < 0.0:
icsa3new[i] = int(sa3new[i]-1.0)
else:
icsa3new[i] = int(sa3new[i]+1.0)
print(icsa1new)
print(icsa2new)
print(icsa3new)
for i in range(3):
if icsa1new[i] == 0:
raise RuntimeError('icsa1new[i] == 0')
if icsa2new[i] == 0:
raise RuntimeError('icsa2new[i] == 0')
if icsa3new[i] == 0:
raise RuntimeError('icsa3new[i] == 0')
irange1 = (min(icsa1new[0],icsa2new[0],icsa3new[0]),
max(icsa1new[0],icsa2new[0],icsa3new[0]))
irange2 = (min(icsa1new[1],icsa2new[1],icsa3new[1]),
max(icsa1new[1],icsa2new[1],icsa3new[1]))
irange3 = (min(icsa1new[2],icsa2new[2],icsa3new[2]),
max(icsa1new[2],icsa2new[2],icsa3new[2]))
print('irange1: ',irange1)
print('irange2: ',irange2)
print('irange3: ',irange3)
expos = []
symbols = psys.get_symbols()
print('symbols :',symbols)
exsymbols = []
print('Expanding the original system...')
for n3 in range(min(0,irange3[0]),irange3[1]):
for n2 in range(min(0,irange2[0]),irange2[1]):
for n1 in range(min(0,irange1[0]),irange1[1]):
for ia in range(len(spos)):
sposi = copy.deepcopy(spos[ia])
sposi[0] += n1
sposi[1] += n2
sposi[2] += n3
posi = np.dot(hmat,sposi)
symbol = symbols[ia]
# print(ia,n1,n2,n3,symbol,sposi)
expos.append(posi)
exsymbols.append(symbol)
print('Extracting the atoms inside the new unit vectors...')
hmat= psnew.get_hmat()
hi = np.linalg.inv(hmat)
for ia,posi in enumerate(expos):
sposi = np.dot(hi,posi)
if 0.0 <= sposi[0] < 1.0 and \
0.0 <= sposi[1] < 1.0 and \
0.0 <= sposi[2] < 1.0:
atom = Atom()
symbol = exsymbols[ia]
print('{0:5d} {1:s}'.format(ia,symbol)
+' {0:12.5f} {1:12.5f} {2:12.5f}'.format(sposi[0],
sposi[1],
sposi[2]))
atom.set_symbol(symbol)
atom.set_pos(sposi[0],sposi[1],sposi[2])
psnew.add_atom(atom)
tmp = None
#tmp = raw_input('Input periodic shift vector if you want: ')
tmp = ' 0.5, 0.0, 0.5'
if tmp:
shift = [ float(x) for x in tmp.split(',')]
for a in psnew.atoms:
a.pos[0] += shift[0]
a.pos[1] += shift[1]
a.pos[2] += shift[2]
psnew.assign_pbc()
psnew.write_POSCAR(infile+'.new')
print('Check '+infile+'.new')
def get_msd(files, ids0, nmeasure, nshift, specorder=None):
"""
Compute MSD of specified species-ID from sequential structure FILES.
Parameters
----------
files: list
List of files used for the MSD calculation.
ids0: list
List of atom-IDs (starting from 1) whose MSDs are to be computed.
nmeasure: int
Number of staggered lanes to compute MSD for better statistics.
nshift: int
Number of files to be skipped for each staggered lane.
specorder: list
Order of species.
Returns
-------
msd : Numpy array of dimension, (len(files),nmeasure,3).
"""
if specorder is not None:
nsys = NAPSystem(fname=files[0], specorder=specorder)
else:
nsys = NAPSystem(fname=files[0], )
specorder = copy.copy(nsys.specorder)
nspc = len(specorder)
if ids0 is not None:
ids = [i - 1 for i in ids0]
sids = nsys.atoms.sid
naps = [0 for i in len(specorder)]
for i in ids0:
sid = sids[i]
naps[sid - 1] += 1
else:
ids = [i for i in range(nsys.num_atoms())]
naps = nsys.natm_per_species()
symbols = nsys.get_symbols()
p0 = np.zeros((nmeasure, len(ids), 3))
pp = np.zeros((len(ids), 3))
# msd= np.zeros((len(files),nmeasure,nspc,3))
msd = np.zeros(
(len(files) - (nmeasure - 1) * nshift + 1, nmeasure, nspc, 3))
npbc = np.zeros((len(ids), 3))
hmat = np.zeros((3, 3))
for ifile in range(len(files)):
fname = files[ifile]
sys.stdout.write(
'\r{0:5d}/{1:d}: {2:s}'.format(ifile + 1, len(files), fname), )
sys.stdout.flush()
if ifile != 0:
nsys = NAPSystem(fname=fname, specorder=specorder)
poss = nsys.atoms.pos
sids = nsys.atoms.sid
hmat = nsys.get_hmat()
for ia, idi in enumerate(ids):
# #...human-readable ID to computer-oriented ID
# i= idi - 1
pi = poss[idi]
sid = sids[idi] - 1
if ifile == 0:
pp[ia, :] = pi[:]
else:
#...correct periodic motion
dev = pi - pp[ia]
if dev[0] > 0.5:
npbc[ia, 0] += -1.0
elif dev[0] < -0.5:
npbc[ia, 0] += 1.0
if dev[1] > 0.5:
npbc[ia, 1] += -1.0
elif dev[1] < -0.5:
npbc[ia, 1] += 1.0
if dev[2] > 0.5:
npbc[ia, 2] += -1.0
elif dev[2] < -0.5:
npbc[ia, 2] += 1.0
# print npbc
#...store current position
pp[ia, :] = pi[:]
for nm in range(nmeasure):
if ifile == nm * nshift:
p0[nm, ia, 0] = pi[0] + npbc[ia, 0]
p0[nm, ia, 1] = pi[1] + npbc[ia, 1]
p0[nm, ia, 2] = pi[2] + npbc[ia, 2]
if nm * nshift < ifile <= (nm + 1) * nshift:
#...normalized to absolute
dev[0] = pi[0] + npbc[ia, 0] - p0[nm, ia, 0]
dev[1] = pi[1] + npbc[ia, 1] - p0[nm, ia, 1]
dev[2] = pi[2] + npbc[ia, 2] - p0[nm, ia, 2]
dev = np.dot(hmat, dev)
msd[ifile - nm * nshift, nm, sid, 0] += dev[0]**2
msd[ifile - nm * nshift, nm, sid, 1] += dev[1]**2
msd[ifile - nm * nshift, nm, sid, 2] += dev[2]**2
for ifile in range(len(files)):
for nm in range(nmeasure):
if nm * nshift < ifile <= (nm + 1) * nshift:
msd[ifile - nm * nshift, nm, :, 0] /= naps[:]
msd[ifile - nm * nshift, nm, :, 1] /= naps[:]
msd[ifile - nm * nshift, nm, :, 2] /= naps[:]
print('')
return msd, specorder
