def _get_mol_details(self, atoms):
"""returns the atomic configuration of the gaussian input file"""
if 'allcheck' in self.route_self_params['geom'].lower():
return ''
mol_details = ''
charge = sum(atoms.get_charges())
mol_details += '%i %i\n' % (charge, self.multiplicity)
if 'check' in self.route_self_params['geom'].lower():
return mol_details
symbols = atoms.get_chemical_symbols()
coordinates = atoms.get_positions()
for i in range(len(atoms)):
mol_details += '%-10s' % symbols[i]
for j in range(3):
mol_details += '%20.10f' % coordinates[i, j]
mol_details += '\n'
mol_details += '\n'
return mol_details
def _get_mol_details(self, atoms):
"""returns the atomic configuration of the gaussian input file"""
if 'allcheck' in self.route_self_params['geom'].lower():
return ''
mol_details = ''
charge = sum(atoms.get_charges())
mol_details += '%i %i\n' % (charge, self.multiplicity)
if 'check' in self.route_self_params['geom'].lower():
return mol_details
symbols = atoms.get_chemical_symbols()
coordinates = atoms.get_positions()
for i in range(len(atoms)):
mol_details += '%-10s' % symbols[i]
for j in range(3):
mol_details += '%20.10f' % coordinates[i, j]
mol_details += '\n'
mol_details += '\n'
return mol_details
def get_localEnv(frame, centerIdx, cutoff, onlyDict=False):
'''
Get the local atomic environment around an atom in an atomic frame.
:param frame: ase or quippy Atoms object
:param centerIdx: int
Index of the local environment center.
:param cutoff: float
Cutoff radius of the local environment.
:return: ase Atoms object
Local atomic environment. The center atom is in first position.
'''
import ase.atoms
import quippy.atoms
from ase.neighborlist import NeighborList
from ase import Atoms as aseAtoms
if isinstance(frame, quippy.atoms.Atoms):
atoms = qp2ase(frame)
elif isinstance(frame, ase.atoms.Atoms):
atoms = frame
else:
raise ValueError
n = len(atoms.get_atomic_numbers())
nl = NeighborList([
cutoff / 2.,
] * n,
skin=0.,
sorted=False,
self_interaction=False,
bothways=True)
nl.build(atoms)
cell = atoms.get_cell()
pbc = atoms.get_pbc()
pos = atoms.get_positions()
positions = [
pos[centerIdx],
]
zList = atoms.get_atomic_numbers()
numbers = [
zList[centerIdx],
]
indices, offsets = nl.get_neighbors(centerIdx)
# print offsets,len(atom.get_atomic_numbers())
for i, offset in zip(indices, offsets):
positions.append(pos[i] + np.dot(offset, cell))
numbers.append(zList[i])
atomsParam = dict(numbers=numbers, cell=cell, positions=positions, pbc=pbc)
if onlyDict:
return atomsParam
else:
return aseAtoms(**atomsParam)
def vibmodes(atoms,
startdir=None,
mask=None,
workhere=False,
save=None,
give_output=0,
pmap=pmap3,
**kwargs):
"""
Wrapper around vibmode, which used the atoms objects
The hessian is calculated by derivatef
qfunc.fwrapper is used as a wrapper to calulate the gradients
"""
from pts.memoize import Memoize, DirStore
coord = atoms.get_positions()
if mask == None:
mask = constraints2mask(atoms)
if mask == None: # (if still None)
fun = Cartesian()
else:
fun = Masked(Cartesian(), mask, coord.flatten())
xcenter = fun.pinv(coord)
myfunc = QFunc(atoms, atoms.get_calculator())
myfunc = Memoize(myfunc, DirStore("cache.d"))
myfunc = compose(myfunc, fun)
pmapc = pwrapper(pmap)
func = fwrapper(myfunc, startdir=startdir, mask=mask, workhere=workhere)
# the derivatives are needed
hessian = derivatef(func, xcenter, pmap=pmapc, **kwargs)
# save is assumend to be a filename, so far only the hessian is saved:
if save is not None:
savetxt(save, hessian)
mass = mass_matrix(atoms.get_masses(), mask)
freqs, modes = vibmod(mass, hessian)
# the output will be printed on demand, with modes if wanted
# the output for the freqs can easily be recreated later on, but
# for the mode vectors the mass (not included in the direct output_
# is needed
if VERBOSE or give_output == 2:
output(freqs, modes, mass, mask)
elif give_output == 1:
output(freqs)
return freqs, modes
def dft_d_pbc(atoms, scaling_factor=0.75, interactionlist=None, interactionmatrix=None, cutoff_radius=DF_CUTOFF_RADIUS):
"""Main function making the D-G06 DFT-D correction available for
systems with periodic boundary conditions. Applies the lattice
summation defined in "lattice_sum" to the intra- and inter-cell
evaluation of the D-G06 correction carried out in "d_g06_cell".
>>> HCldim = Atoms('Cl2')
>>> x1 = ( 1.65, 0, -0.01)
>>> x2 = (-1.65, 0, 0.01)
>>> HCldim.set_positions([x1,x2])
>>> HCldim.set_atomic_numbers([ 17, 17])
>>> HCldim.set_cell([(10.0, 0.0, 0.0), (0.0, 10.0, 0.0), (0.0, 0.0, 3.3)])
>>> HCldim.set_pbc([False,]*3)
>>> dft_d_pbc(HCldim)
(-0.016281380498314325, array([[-0.01672876, 0. , 0.00010139],
[ 0.01672876, 0. , -0.00010139]]))
>>> iso_c, iso_g = dft_d_iso(HCldim)
>>> pbc_c, pbc_g = dft_d_pbc(HCldim)
>>> iso_c == pbc_c, iso_g == pbc_g
(True, array([[ True, True, True],
[ True, True, True]], dtype=bool))
"""
#
# Obtain data about system
atom_numbers = atoms.get_atomic_numbers()
positions = atoms.get_positions()
periodic_directions = atoms.get_pbc()
elem_cell = atoms.get_cell()
#
# Number of atoms within a single copy
N_atoms = len(positions)
#
# Check input i.e. if interactionlist and interactionmatrix are set properly
interactionlist, interactionmatrix = check_interaction_group_input(N_atoms, interactionlist, interactionmatrix)
#
# Start with Calculation
# Get DFT-D parameters
params = [d_g06_parameters(ind_1) for ind_1 in atom_numbers]
#
# Define function "func" as "d_g06" for the lattice summation done in "lattice_sum"
def func(t):
return d_g06_cell(N_atoms, params, positions, interactionlist, interactionmatrix, cutoff_radius, t_vec=t)
#
# Call lattice summation with function "d_g06_cell"
dispersion_correction, gradient_contribution = lattice_sum(
func, positions, elem_cell, periodic_directions, cutoff_radius
)
#
# Scale dispersion correction and forces according to used XC-functional
dispersion_correction = dispersion_correction * scaling_factor
gradient_contribution = gradient_contribution * scaling_factor
#
return dispersion_correction, gradient_contribution
def vibmodes(atoms, startdir=None, mask=None, workhere=False, save=None, give_output = 0, pmap = pmap3, **kwargs):
"""
Wrapper around vibmode, which used the atoms objects
The hessian is calculated by derivatef
qfunc.fwrapper is used as a wrapper to calulate the gradients
"""
from pts.memoize import Memoize, DirStore
coord = atoms.get_positions()
if mask == None:
mask = constraints2mask(atoms)
if mask == None: # (if still None)
fun = Cartesian()
else:
fun = Masked(Cartesian(), mask, coord.flatten())
xcenter = fun.pinv(coord)
myfunc = QFunc(atoms, atoms.get_calculator())
myfunc = Memoize(myfunc, DirStore("cache.d"))
myfunc = compose( myfunc, fun)
pmapc = pwrapper(pmap)
func = fwrapper(myfunc, startdir = startdir, mask = mask, workhere = workhere)
# the derivatives are needed
hessian = derivatef( func, xcenter, pmap = pmapc, **kwargs)
# save is assumend to be a filename, so far only the hessian is saved:
if save is not None:
savetxt(save, hessian)
mass = mass_matrix (atoms.get_masses(), mask)
freqs, modes = vibmod(mass, hessian)
# the output will be printed on demand, with modes if wanted
# the output for the freqs can easily be recreated later on, but
# for the mode vectors the mass (not included in the direct output_
# is needed
if VERBOSE or give_output == 2:
output(freqs, modes, mass, mask)
elif give_output == 1:
output(freqs)
return freqs, modes
def dft_d_iso(atoms, scaling_factor=0.75, interactionlist=None, interactionmatrix=None, cutoff_radius=DF_CUTOFF_RADIUS):
"""Main function making the D-G06 DFT-D correction available for
isolated systems. Consists in the application of an intra-cell
evaluation of the D-G06 correction carried out in "d_g06_cell".
>>> HCldim = Atoms('Cl2')
>>> x1 = ( 1.65, 0, -0.01)
>>> x2 = (-1.65, 0, 0.01)
>>> HCldim.set_positions([x1,x2])
>>> HCldim.set_atomic_numbers([ 17, 17])
>>> dft_d_pbc(HCldim)
(-0.016281380498314325, array([[-0.01672876, 0. , 0.00010139],
[ 0.01672876, 0. , -0.00010139]]))
"""
#
# Obtain data about system
atom_numbers = atoms.get_atomic_numbers()
positions = atoms.get_positions()
#
# Number of atoms within a single copy
N_atoms = len(positions)
#
# Check input i.e. if interactionlist and interactionmatrix are set properly
interactionlist, interactionmatrix = check_interaction_group_input(N_atoms, interactionlist, interactionmatrix)
interactionmatrix = np.array(interactionmatrix)
#
# Start with Calculation
# Get DFT-D parameters
params = [d_g06_parameters(ind_1) for ind_1 in atom_numbers]
#
# Define function "func" as "d_g06" for the lattice summation done in "lattice_sum"
dispersion_correction, gradient_contribution = d_g06_cell(
N_atoms, params, positions, interactionlist, interactionmatrix, cutoff_radius
)
#
# Scale dispersion correction and forces according to used XC-functional
dispersion_correction = dispersion_correction * scaling_factor
gradient_contribution = gradient_contribution * scaling_factor
#
return dispersion_correction, gradient_contribution
def initialize_sdc(self, atoms=None):
""" Initialization of all parameters in the sedc-module.
Here we initialize all parameters in order to successfully calculate
with sdc_recode module. The priority of parameters is user > default >
dummy. The bare minimum of required parameters is:
* atoms [ ASE atoms-object of the system treated ]
* sedc_n_groups [ integer, number of differently treated groups ]
* sedc_groups [ array of integers, number of atoms per group ]
* sedc_pbc_switches [ np.array of 6-dim vectors specifying the VdW
contributions in A,B,C in positive and
negative direction ]
This has to be done after the creation of our calculator-object,
because otherwise we do not have the atoms-module to calculate most of
the required properties.
"""
for arg in self.valid_args:
if hasattr(self, arg):
# In order to avoid lengthy np-initialization in aims-script
if (arg == 'sedc_pbc_g_switches'):
setattr(sdc.sdc_recode, arg,
eval('np.transpose(self.' + arg + ')'))
elif (arg == 'sedc_tssurf_vfree_div_vbulk'):
tmp_array = \
np.array(([1] * atoms.get_number_of_atoms()),
np.float64)
species = []
n_species = 0
for atom in atoms:
species_i = atom.number
if species_i not in species:
species.append(species_i)
n_species += 1
species.sort()
for i,a in enumerate(atoms):
for ss, s in enumerate(species):
if s==a.number:
tmp_array[i] = \
self.sedc_tssurf_vfree_div_vbulk[ss]
sdc.sdc_recode.sedc_tssurf_vfree_div_vbulk = \
tmp_array
else:
setattr(sdc.sdc_recode, arg, eval('self.' + arg))
elif arg in self.default_parameters:
setattr(sdc.sdc_recode, arg, self.default_parameters[arg])
else:
if (arg == 'internal_cart_coord'):
sdc.sdc_recode.internal_cart_coord = \
atoms.get_positions().transpose().copy()
elif (arg == 'sedc_cart_coord'):
sdc.sdc_recode.sedc_cart_coord = \
atoms.get_positions().transpose().copy()
elif (arg == 'sedc_cell_vectors'):
sdc.sdc_recode.sedc_cell_vectors = \
atoms.get_cell().transpose().copy()
elif (arg == 'sedc_species'):
sdc.sdc_recode.sedc_species = \
atoms.get_atomic_numbers().copy()
elif (arg == 'sedc_n_ions'):
sdc.sdc_recode.sedc_n_ions = \
atoms.get_number_of_atoms()
elif (arg == 'sedc_pbc_g_fold'):
sdc.sdc_recode.sedc_pbc_g_fold = [0] * self.sedc_n_groups
elif (arg == 'sedc_ts_veff_div_vfree'):
if not self.hirshvolrat_is_set:
sdc.sdc_recode.sedc_ts_veff_div_vfree = \
np.array(([1] * atoms.get_number_of_atoms()),
np.float64)
elif (arg == 'sedc_tssurf_vfree_div_vbulk'):
sdc.sdc_recode.sedc_tssurf_vfree_div_vbulk = \
np.array(([1] * atoms.get_number_of_atoms()),
np.float64)
elif (arg == 'sedc_skip_atom'):
sdc.sdc_recode.sedc_skip_atom = \
np.array(([-1] * atoms.get_number_of_atoms()),
np.float64)
elif (arg == 'sedc_pbc_g_only_intra'):
sdc.sdc_recode.sedc_pbc_g_only_intra = \
[0] * self.sedc_n_groups
elif (arg == 'sedc_pbc_g_cells'):
sdc.sdc_recode.sedc_pbc_g_cells = \
np.tile(atoms.get_cell().transpose().copy(),
(1, self.sedc_n_groups))
elif (arg == 'sedc_pbc_g_skip'):
sdc.sdc_recode.sedc_pbc_g_skip = [0] * self.sedc_n_groups
else:
print("You've been sloppy my friend. :) Variable:", arg, \
" does not exist!")
import numpy as np
from ase import io, atoms
Temp = '300'
atoms = io.read('POSCAR')
pos = atoms.get_positions()
disp = np.loadtxt('thermal_displacements.yaml', skiprows=6, usecols=(2, 3, 4))
pos += disp
atoms.set_positions(pos)
io.write('POSCAR' + Temp, atoms, direct=True)