def from_file(cls, fname, spacing=0.2, extension=5.0, rotate=True):
"""
Initialize ``UniformGrid`` class based on the grid specifications of a file.
Parameters
----------
fname : str
Path to molecule's file.
spacing : float, optional
Increment between grid points along `x`, `y` and `z` direction.
extension : float, optional
The extension of the cube on each side of the molecule.
rotate : bool, optional
When True, the molecule is rotated so the axes of the cube file are
aligned with the principle axes of rotation of the molecule.
"""
# Load file
logging.basicConfig(level=logging.INFO,
format='%(levelname)s: %(message)s')
try:
mol = IOData.from_file(str(fname))
except IOError as _:
try:
with path('chemtools.data.examples', str(fname)) as fname:
logging.info('Loading {0}'.format(str(fname)))
mol = IOData.from_file(str(fname))
except IOError as error:
logging.info(error)
return cls.from_molecule(mol, spacing, extension, rotate)
def main():
args = parse_args()
fn_h5, grp_name = parse_h5(args.output, 'output')
# check if the group is already present (and not empty) in the output file
if check_output(fn_h5, grp_name, args.overwrite):
return
# Load the cost function from the HDF5 file
cost, used_volume = load_cost(args.cost)
# Find the optimal charges
results = {}
results['x'] = cost.solve(args.qtot, args.ridge)
results['charges'] = results['x'][:cost.natom]
# Related properties
results['cost'] = cost.value(results['x'])
if results['cost'] < 0:
results['rmsd'] = 0.0
else:
results['rmsd'] = (results['cost'] / used_volume)**0.5
# Worst case stuff
results['cost_worst'] = cost.worst(0.0)
if results['cost_worst'] < 0:
results['rmsd_worst'] = 0.0
else:
results['rmsd_worst'] = (results['cost_worst'] / used_volume)**0.5
# Write some things on screen
if log.do_medium:
log('Important parameters:')
log.hline()
log('RMSD charges: %10.5e' % np.sqrt(
(results['charges']**2).mean()))
log('RMSD ESP: %10.5e' % results['rmsd'])
log('Worst RMSD ESP: %10.5e' % results['rmsd_worst'])
log.hline()
# Perform a symmetry analysis if requested
if args.symmetry is not None:
mol_pot = IOData.from_file(args.symmetry[0])
mol_sym = IOData.from_file(args.symmetry[1])
if not hasattr(mol_sym, 'symmetry'):
raise ValueError('No symmetry information found in %s.' %
args.symmetry[1])
aim_results = {'charges': results['charges']}
sym_results = symmetry_analysis(mol_pot.coordinates, mol_pot.cell,
mol_sym.symmetry, aim_results)
results['symmetry'] = sym_results
# Store the results in an HDF5 file
write_script_output(fn_h5, grp_name, results, args)
def main():
args = parse_args()
fn_h5, grp_name = parse_h5(args.output, 'output')
# check if the group is already present (and not empty) in the output file
if check_output(fn_h5, grp_name, args.overwrite):
return
# Load the cost function from the HDF5 file
cost, used_volume = load_cost(args.cost)
# Find the optimal charges
results = {}
results['x'] = cost.solve(args.qtot, args.ridge)
results['charges'] = results['x'][:cost.natom]
# Related properties
results['cost'] = cost.value(results['x'])
if results['cost'] < 0:
results['rmsd'] = 0.0
else:
results['rmsd'] = (results['cost']/used_volume)**0.5
# Worst case stuff
results['cost_worst'] = cost.worst(0.0)
if results['cost_worst'] < 0:
results['rmsd_worst'] = 0.0
else:
results['rmsd_worst'] = (results['cost_worst']/used_volume)**0.5
# Write some things on screen
if log.do_medium:
log('Important parameters:')
log.hline()
log('RMSD charges: %10.5e' % np.sqrt((results['charges']**2).mean()))
log('RMSD ESP: %10.5e' % results['rmsd'])
log('Worst RMSD ESP: %10.5e' % results['rmsd_worst'])
log.hline()
# Perform a symmetry analysis if requested
if args.symmetry is not None:
mol_pot = IOData.from_file(args.symmetry[0])
mol_sym = IOData.from_file(args.symmetry[1])
if not hasattr(mol_sym, 'symmetry'):
raise ValueError('No symmetry information found in %s.' % args.symmetry[1])
aim_results = {'charges': results['charges']}
sym_results = symmetry_analysis(mol_pot.coordinates, mol_pot.cell, mol_sym.symmetry, aim_results)
results['symmetry'] = sym_results
# Store the results in an HDF5 file
write_script_output(fn_h5, grp_name, results, args)
def main():
args = parse_args()
margin = args.margin*angstrom
spacing = args.spacing*angstrom
mol = IOData.from_file(args.structure)
# compute the shape tensor
shape = np.dot(mol.coordinates.transpose(), mol.coordinates)
# diagonalize to obtain the x, y and z directions.
evals, evecs = np.linalg.eigh(shape)
axes = evecs.transpose()*spacing
# compute the origin and the number of repetitions along each axis.
nrep = np.zeros(3, int)
origin = np.zeros(3, float)
for i in xrange(3):
projc = np.dot(mol.coordinates, evecs[:,i])
nrep[i] = np.ceil((projc.max() - projc.min() + 2*margin)/spacing)+1
origin += 0.5*(projc.max() + projc.min() - (nrep[i]-1)*spacing)*evecs[:,i]
with open(args.output, 'w') as f:
# the header is written in Bohr, hence the -nrep[0]
print >> f, '% 5i % 15.10f % 15.10f % 15.10f' % (0, origin[0], origin[1], origin[2])
print >> f, '% 5i % 15.10f % 15.10f % 15.10f' % (-nrep[0], axes[0,0], axes[0,1], axes[0,2])
print >> f, '% 5i % 15.10f % 15.10f % 15.10f' % (nrep[1], axes[1,0], axes[1,1], axes[1,2])
print >> f, '% 5i % 15.10f % 15.10f % 15.10f' % (nrep[2], axes[2,0], axes[2,1], axes[2,2])
def load_atom(self, dn_mult, ext):
fn = "%s/atom.%s" % (dn_mult, ext)
if not os.path.isfile(fn):
return None, None
try:
mol = IOData.from_file(fn)
except:
return None, None
mol.energy = self._get_energy(mol, dn_mult)
return mol, mol.energy
def load_atom(self, dn_mult, ext):
fn = '%s/atom.%s' % (dn_mult, ext)
if not os.path.isfile(fn):
return None, None
try:
mol = IOData.from_file(fn)
except:
return None, None
mol.energy = self._get_energy(mol, dn_mult)
return mol, mol.energy
def write_random_lta_cube(dn, fn_cube):
'''Write a randomized cube file'''
# start from an existing cube file
mol = IOData.from_file(context.get_fn('test/lta_gulp.cif'))
# Define a uniform grid with only 1000 points, to make the tests fast.
ugrid = UniformGrid(np.zeros(3, float), mol.cell.rvecs*0.1, np.array([10, 10, 10]), np.array([1, 1, 1]))
# Write to the file dn/fn_cube
mol.cube_data = np.random.uniform(0, 1, ugrid.shape)
mol.grid = ugrid
mol.to_file(os.path.join(dn, fn_cube))
return mol
def from_file(cls, fname):
"""Initialize class given a file.
Parameters
----------
fname : str
Path to molecule"s files.
"""
# load molecule
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
try:
iodata = IOData.from_file(str(fname))
except IOError as _:
try:
with path("chemtools.data.examples", str(fname)) as fname:
logging.info("Loading {0}".format(str(fname)))
iodata = IOData.from_file(str(fname))
except IOError as error:
logging.info(error)
return cls(iodata)
def from_file(cls, fname, wavefunction=False):
"""Initialize class given a file.
Parameters
----------
fname : str
Path to molecule's files.
"""
# load molecule
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
try:
iodata = IOData.from_file(str(fname))
except IOError as _:
try:
with path('chemtools.data.examples', str(fname)) as fname:
logging.info('Loading {0}'.format(str(fname)))
iodata = IOData.from_file(str(fname))
except IOError as error:
logging.info(error)
return cls(iodata, wavefunction)
def write_random_lta_cube(dn, fn_cube):
'''Write a randomized cube file'''
# start from an existing cube file
mol = IOData.from_file(context.get_fn('test/lta_gulp.cif'))
# Define a uniform grid with only 1000 points, to make the tests fast.
ugrid = UniformGrid(np.zeros(3, float), mol.cell.rvecs * 0.1,
np.array([10, 10, 10]), np.array([1, 1, 1]))
# Write to the file dn/fn_cube
mol.cube_data = np.random.uniform(0, 1, ugrid.shape)
mol.grid = ugrid
mol.to_file(os.path.join(dn, fn_cube))
return mol
def load_rho(coordinates, numbers, fn_cube, ref_ugrid, stride, chop):
'''Load densities from a file, reduce by stride, chop and check ugrid
**Arguments:**
coordinates
An array with shape (N, 3) containing atomic coordinates.
numbers
A vector with shape (N,) containing atomic numbers.
fn_cube
The cube file with the electron density.
ref_ugrid
A reference ugrid that must match the one from the density cube
file (after reduction).
stride
The reduction factor.
chop
The number of slices to chop of the grid in each direction.
'''
if fn_cube is None:
# Load the built-in database of proatoms
natom = len(numbers)
numbers = np.unique(numbers)
proatomdb = ProAtomDB.from_refatoms(numbers,
max_kation=0,
max_anion=0,
agspec='fine')
# Construct the pro-density
rho = np.zeros(ref_ugrid.shape)
for i in xrange(natom):
spline = proatomdb.get_spline(numbers[i])
ref_ugrid.eval_spline(spline, coordinates[i], rho)
else:
# Load cube
mol_rho = IOData.from_file(fn_cube)
rho = mol_rho.cube_data
ugrid = mol_rho.grid
# Reduce grid size
if stride > 1:
rho, ugrid = reduce_data(rho, ugrid, stride, chop)
# Compare with ref_ugrid (only shape)
if (ugrid.shape != ref_ugrid.shape).any():
raise ValueError(
'The densities file does not contain the same amount if information as the potential file.'
)
return rho
def main():
args = parse_args()
fn_h5, grp_name = parse_h5(args.output, 'output')
# check if the group is already present (and not empty) in the output file
if check_output(fn_h5, grp_name, args.overwrite):
return
# Load the system
mol = IOData.from_file(args.wfn)
# Define a list of optional arguments for the WPartClass:
WPartClass = wpart_schemes[args.scheme]
kwargs = dict((key, val) for key, val in vars(args).iteritems()
if key in WPartClass.options)
# Load the proatomdb
if args.atoms is not None:
proatomdb = ProAtomDB.from_file(args.atoms)
proatomdb.normalize()
kwargs['proatomdb'] = proatomdb
else:
proatomdb = None
# Run the partitioning
agspec = AtomicGridSpec(args.grid)
grid = BeckeMolGrid(mol.coordinates,
mol.numbers,
mol.pseudo_numbers,
agspec,
mode='only')
dm_full = mol.get_dm_full()
moldens = mol.obasis.compute_grid_density_dm(dm_full,
grid.points,
epsilon=args.epsilon)
dm_spin = mol.get_dm_spin()
if dm_spin is not None:
kwargs['spindens'] = mol.obasis.compute_grid_density_dm(
dm_spin, grid.points, epsilon=args.epsilon)
wpart = wpart_schemes[args.scheme](mol.coordinates, mol.numbers,
mol.pseudo_numbers, grid, moldens,
**kwargs)
keys = wpart.do_all()
if args.slow:
# ugly hack for the slow analysis involving the AIM overlap operators.
wpart_slow_analysis(wpart, mol)
keys = list(wpart.cache.iterkeys(tags='o'))
write_part_output(fn_h5, grp_name, wpart, keys, args)
def load_rho(coordinates, numbers, fn_cube, ref_ugrid, stride, chop):
'''Load densities from a file, reduce by stride, chop and check ugrid
**Arguments:**
coordinates
An array with shape (N, 3) containing atomic coordinates.
numbers
A vector with shape (N,) containing atomic numbers.
fn_cube
The cube file with the electron density.
ref_ugrid
A reference ugrid that must match the one from the density cube
file (after reduction).
stride
The reduction factor.
chop
The number of slices to chop of the grid in each direction.
'''
if fn_cube is None:
# Load the built-in database of proatoms
natom = len(numbers)
numbers = np.unique(numbers)
proatomdb = ProAtomDB.from_refatoms(numbers, max_kation=0, max_anion=0, agspec='fine')
# Construct the pro-density
rho = np.zeros(ref_ugrid.shape)
for i in xrange(natom):
spline = proatomdb.get_spline(numbers[i])
ref_ugrid.eval_spline(spline, coordinates[i], rho)
else:
# Load cube
mol_rho = IOData.from_file(fn_cube)
rho = mol_rho.cube_data
ugrid = mol_rho.grid
# Reduce grid size
if stride > 1:
rho, ugrid = reduce_data(rho, ugrid, stride, chop)
# Compare with ref_ugrid (only shape)
if (ugrid.shape != ref_ugrid.shape).any():
raise ValueError('The densities file does not contain the same amount if information as the potential file.')
return rho
def main():
args = parse_args()
fn_h5, grp_name = parse_h5(args.output, 'output')
# check if the group is already present (and not empty) in the output file
if check_output(fn_h5, grp_name, args.overwrite):
return
# Load the system
mol = IOData.from_file(args.wfn)
# Define a list of optional arguments for the WPartClass:
WPartClass = wpart_schemes[args.scheme]
kwargs = dict((key, val) for key, val in vars(args).iteritems() if key in WPartClass.options)
# Load the proatomdb
if args.atoms is not None:
proatomdb = ProAtomDB.from_file(args.atoms)
proatomdb.normalize()
kwargs['proatomdb'] = proatomdb
else:
proatomdb = None
# Run the partitioning
agspec = AtomicGridSpec(args.grid)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, agspec, mode='only')
dm_full = mol.get_dm_full()
moldens = mol.obasis.compute_grid_density_dm(dm_full, grid.points, epsilon=args.epsilon)
dm_spin = mol.get_dm_spin()
if dm_spin is not None:
kwargs['spindens'] = mol.obasis.compute_grid_density_dm(dm_spin, grid.points, epsilon=args.epsilon)
wpart = wpart_schemes[args.scheme](mol.coordinates, mol.numbers, mol.pseudo_numbers,grid, moldens, **kwargs)
keys = wpart.do_all()
if args.slow:
# ugly hack for the slow analysis involving the AIM overlap operators.
wpart_slow_analysis(wpart, mol)
keys = list(wpart.cache.iterkeys(tags='o'))
write_part_output(fn_h5, grp_name, wpart, keys, args)
def main():
args = parse_args()
fn_h5, grp_name = parse_h5(args.output, 'output')
# check if the group is already present (and not empty) in the output file
if check_output(fn_h5, grp_name, args.overwrite):
return
# Load the IOData
mol = IOData.from_file(args.cube)
ugrid = mol.grid
if not isinstance(ugrid, UniformGrid):
raise TypeError('The density cube file does not contain data on a rectangular grid.')
ugrid.pbc[:] = parse_pbc(args.pbc)
moldens = mol.cube_data
# Reduce the grid if required
if args.stride > 1 or args.chop > 0:
moldens, ugrid = reduce_data(moldens, ugrid, args.stride, args.chop)
# Load the spin density (optional)
if args.spindens is not None:
molspin = IOData.from_file(args.spindens)
if not isinstance(molspin.grid, UniformGrid):
raise TypeError('The spin cube file does not contain data on a rectangular grid.')
spindens = molspin.cube_data
if args.stride > 1 or args.chop > 0:
spindens = reduce_data(spindens, molspin.grid, args.stride, args.chop)[0]
if spindens.shape != moldens.shape:
raise TypeError('The shape of the spin cube does not match the shape of the density cube.')
else:
spindens = None
# Load the proatomdb and make pro-atoms more compact if that is requested
proatomdb = ProAtomDB.from_file(args.atoms)
if args.compact is not None:
proatomdb.compact(args.compact)
proatomdb.normalize()
# Select the partitioning scheme
CPartClass = cpart_schemes[args.scheme]
# List of element numbers for which weight corrections are needed:
if args.wcor == '0':
wcor_numbers = []
else:
wcor_numbers = list(iter_elements(args.wcor))
# Run the partitioning
kwargs = dict((key, val) for key, val in vars(args).iteritems() if key in CPartClass.options)
cpart = cpart_schemes[args.scheme](
mol.coordinates, mol.numbers, mol.pseudo_numbers, ugrid, moldens,
proatomdb, spindens=spindens, local=True, wcor_numbers=wcor_numbers,
wcor_rcut_max=args.wcor_rcut_max, wcor_rcond=args.wcor_rcond, **kwargs)
keys = cpart.do_all()
# Do a symmetry analysis if requested.
if args.symmetry is not None:
mol_sym = IOData.from_file(args.symmetry)
if not hasattr(mol_sym, 'symmetry'):
raise ValueError('No symmetry information found in %s.' % args.symmetry)
aim_results = dict((key, cpart[key]) for key in keys)
sym_results = symmetry_analysis(mol.coordinates, ugrid.get_cell(), mol_sym.symmetry, aim_results)
cpart.cache.dump('symmetry', sym_results)
keys.append('symmetry')
write_part_output(fn_h5, grp_name, cpart, keys, args)
def load_ugrid_coordinates(arg_grid):
mol = IOData.from_file(arg_grid)
return mol.grid, mol.coordinates
import numpy as np
import sympy as sp
from horton import (context, IOData, get_gobasis, CholeskyLinalgFactory,
guess_core_hamiltonian, compute_nucnuc, RTwoIndexTerm,
RDirectTerm, RExchangeTerm, REffHam, AufbauOccModel)
from polar.data_generate import model_finitefield_ham
# Hartree-Fock calculation
# ------------------------
# Load the coordinates from file.
# Use the XYZ file from HORTON's test data directory.
fn_xyz = context.get_fn('test/water.xyz')
mol = IOData.from_file(fn_xyz)
# Create a Gaussian basis set
obasis = get_gobasis(mol.coordinates, mol.numbers, 'sto-3g')
lf = CholeskyLinalgFactory(obasis.nbasis)
# Create a linalg factory
# Compute Gaussian integrals
olp = obasis.compute_overlap(lf)
kin = obasis.compute_kinetic(lf)
na = obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, lf)
er = obasis.compute_electron_repulsion(lf)
# Create alpha orbitals
orb = lf.create_expansion()
# Initial guess
guess_core_hamiltonian(olp, kin, na, orb)
def read(self, path):
mol = IOData.from_file(path)
end = self.begin + mol.natom
result = [[self.begin, end], mol.numbers, mol.coordinates]
self.begin = end
return result
def main():
args = parse_args()
fn_h5, grp_name = parse_h5(args.output, 'output')
# check if the group is already present (and not empty) in the output file
if check_output(fn_h5, grp_name, args.overwrite):
return
# Load the potential data
if log.do_medium:
log('Loading potential array')
mol_pot = IOData.from_file(args.cube)
if not isinstance(mol_pot.grid, UniformGrid):
raise TypeError('The specified file does not contain data on a rectangular grid.')
mol_pot.grid.pbc[:] = parse_pbc(args.pbc) # correct pbc
esp = mol_pot.cube_data
# Reduce the grid if required
if args.stride > 1:
esp, mol_pot.grid = reduce_data(esp, mol_pot.grid, args.stride, args.chop)
# Fix sign
if args.sign:
esp *= -1
# Some screen info
if log.do_medium:
log('Important parameters:')
log.hline()
log('Number of grid points: %12i' % np.product(mol_pot.grid.shape))
log('Grid shape: [%8i, %8i, %8i]' % tuple(mol_pot.grid.shape))
log('PBC: [%8i, %8i, %8i]' % tuple(mol_pot.grid.pbc))
log.hline()
# Construct the weights for the ESP Cost function.
wdens = parse_wdens(args.wdens)
if wdens is not None:
if log.do_medium:
log('Loading density array')
# either the provided density or a built-in prodensity
rho = load_rho(mol_pot.coordinates, mol_pot.numbers, wdens[0], mol_pot.grid, args.stride, args.chop)
wdens = (rho,) + wdens[1:]
if log.do_medium:
log('Constructing weight function')
weights = setup_weights(mol_pot.coordinates, mol_pot.numbers, mol_pot.grid,
dens=wdens,
near=parse_wnear(args.wnear),
far=parse_wnear(args.wfar),
)
# write the weights to a cube file if requested
if args.wsave is not None:
if log.do_medium:
log(' Saving weights array ')
# construct a new data dictionary that contains all info for the cube file
mol_weights = mol_pot.copy()
mol_weights.cube_data = weights
mol_weights.to_file(args.wsave)
# rescale weights such that the cost function is the mean-square-error
if weights.max() == 0.0:
raise ValueError('No points with a non-zero weight were found')
wmax = weights.min()
wmin = weights.max()
used_volume = mol_pot.grid.integrate(weights)
# Some screen info
if log.do_medium:
log('Important parameters:')
log.hline()
log('Used number of grid points: %12i' % (weights>0).sum())
log('Used volume: %12.5f' % used_volume)
log('Used volume/atom: %12.5f' % (used_volume/mol_pot.natom))
log('Lowest weight: %12.5e' % wmin)
log('Highest weight: %12.5e' % wmax)
log('Max weight at edge: %12.5f' % max_at_edge(weights, mol_pot.grid.pbc))
# Ewald parameters
rcut, alpha, gcut = parse_ewald_args(args)
# Some screen info
if log.do_medium:
log('Ewald real cutoff: %12.5e' % rcut)
log('Ewald alpha: %12.5e' % alpha)
log('Ewald reciprocal cutoff: %12.5e' % gcut)
log.hline()
# Construct the cost function
if log.do_medium:
log('Setting up cost function (may take a while) ')
cost = ESPCost.from_grid_data(mol_pot.coordinates, mol_pot.grid, esp, weights, rcut, alpha, gcut)
# Store cost function info
results = {}
results['cost'] = cost
results['used_volume'] = used_volume
# Store cost function properties
results['evals'] = np.linalg.eigvalsh(cost._A)
abs_evals = abs(results['evals'])
if abs_evals.min() == 0.0:
results['cn'] = 0.0
else:
results['cn'] = abs_evals.max()/abs_evals.min()
# Report some on-screen info
if log.do_medium:
log('Important parameters:')
log.hline()
log('Lowest abs eigen value: %12.5e' % abs_evals.min())
log('Highest abs eigen value: %12.5e' % abs_evals.max())
log('Condition number: %12.5e' % results['cn'])
log.hline()
# Store the results in an HDF5 file
write_script_output(fn_h5, grp_name, results, args)
def read(self, path):
mol = IOData.from_file(path)
end = self.begin + mol.natom
result = [[self.begin, end], mol.numbers, mol.coordinates]
self.begin = end
return result
def main():
args = parse_args()
mol = IOData.from_file(args.input)
mol.to_file(args.output)
def load_ugrid_coordinates(arg_grid):
mol = IOData.from_file(arg_grid)
return mol.grid, mol.coordinates