def _init_ORB_grid(data, grid_par=-6, over_s=7):
u"""Initializes ORBKIT's grid and returns necessary data for visualization.
**Parameters:**
data : dict
QCinfo instance representing the molecule.
grid_par : int
Parameter controlling grid. If positive or zero, it specifies number of points; otherwise it specifies the resolution in inverse atomic units.
over_s : int|float
Oversizing, to be tuned
**Returns**
X, Y, Z
Meshgrid (as returned by numpy.mgrid) for positioning the voxels.
"""
from orbkit import grid
## Reinitialization of the grid
grid.is_initialized = False
## Spacing/Number of points
if grid_par > 0:
grid.N_ = [grid_par] * 3
elif grid_par == 0:
grid.N_ = [80] * 3
else:
grid.delta_ = [1.0 / (-grid_par)] * 3
grid.max_ = np.amax(data.geo_spec, axis=0) + over_s
grid.min_ = np.amin(data.geo_spec, axis=0) - over_s
grid.adjust_to_geo(data, extend=over_s, step=grid.delta_[0])
grid.init(force=True)
## The meshgrid MUST be generated in this manner,
## in order to be maximally consistent with ORBKIT
## which uses numpy.arange to generate its grid
## (i.e. start:stop+step:step)
X, Y, Z = np.mgrid[grid.min_[0]:grid.max_[0] +
grid.delta_[0]:grid.delta_[0],
grid.min_[1]:grid.max_[1] +
grid.delta_[1]:grid.delta_[1],
grid.min_[2]:grid.max_[2] +
grid.delta_[2]:grid.delta_[2]]
## NOTICE: numpy.arange does not return consistent results if step is a float,
## specifically if (stop - start)/step overflows, resulting in
## arange(start, stop, step)[-1] > stop
return X, Y, Z
def orbkit_grid(self, qc):
# Initialize grid
grid.adjust_to_geo(qc, extend=5.0, step=0.4)
grid.grid_init(force=True)
self.slice_length = grid.N_[1] * grid.N_[2] / 2
def run_orbkit(use_qc=None, check_options=True, standalone=False):
'''Controls the execution of all computational tasks.
**Parameters:**
use_qc : QCinfo, optional
If not None, the reading of a quantum chemistry output is omitted and
the given QCinfo class is used for all computational tasks.
(See :ref:`Central Variables` in the manual for details on QCinfo.)
check_options : bool, optional
If True, the specified options will be validated.
**Returns:**
data : type and shape depend on the options.
Contains orbkit's output.
See :ref:`High-Level Interface` in the manual for details.
'''
# Set some global variables
global qc
# Display program information
display(lgpl_short)
# Check for the correctness of orbkit.options
if check_options:
display('Checking orbkit.options...\n')
options.check_options(display=display,
interactive=False,
info=True,
check_io=(use_qc is None))
# Measurement of required execution time
t = [time.time()]
# Do we need to read out the info of all MOs?
if (options.mo_set or options.calc_mo) is not False:
options.all_mo = True
if use_qc is None:
# Read the input file
qc = read.main_read(options.filename,
itype=options.itype,
all_mo=options.all_mo,
spin=options.spin,
cclib_parser=options.cclib_parser)
else:
# Use a user defined QCinfo class.
qc = use_qc
display('\nSetting up the grid...')
if options.grid_file is not None:
# Read the grid from an external file
grid.read(options.grid_file)
elif options.adjust_grid is not None:
# Adjust the grid to geo_spec
extend, step = options.adjust_grid
grid.adjust_to_geo(qc, extend=extend, step=step)
elif options.random_grid:
# Create a randomized grid
grid.random_grid(qc.geo_spec)
# Initialize grid
grid.grid_init(is_vector=options.is_vector)
if options.is_vector:
grid.is_regular = False
display(grid.get_grid()) # Display the grid
if not grid.is_regular and options.center_grid is not None:
raise IOError(
'The option --center is only supported for regular grids.')
elif options.center_grid is not None:
atom = grid.check_atom_select(options.center_grid,
qc.geo_info,
qc.geo_spec,
interactive=True,
display=display)
# Center the grid to a specific atom and (0,0,0) if requested
grid.center_grid(qc.geo_spec[atom - 1], display=display)
if check_options or standalone:
options.check_grid_output_compatibilty()
t.append(time.time()) # A new time step
# The calculation of all AOs (--calc_ao)
if options.calc_ao != False:
data = extras.calc_ao(qc, drv=options.drv, otype=options.otype)
t.append(time.time()) # Final time
good_bye_message(t)
return data
# The calculation of selected MOs (--calc_mo) or
# the density formed by selected MOs (--mo_set)
if (options.mo_set or options.calc_mo) != False:
# What should the program do?
if options.calc_mo != False:
fid_mo_list = options.calc_mo
elif options.mo_set != False:
fid_mo_list = options.mo_set
# Call the function for actual calculation
if options.calc_mo != False:
data = extras.calc_mo(qc,
fid_mo_list,
drv=options.drv,
otype=options.otype)
elif options.mo_set != False:
data = extras.mo_set(qc,
fid_mo_list,
drv=options.drv,
laplacian=options.laplacian,
otype=options.otype)
t.append(time.time()) # Final time
good_bye_message(t)
return data
if options.gross_atomic_density is not None:
atom = options.gross_atomic_density
rho_atom = extras.numerical_mulliken_charges(atom, qc)
if not grid.is_vector:
mulliken_num = rho_atom[1]
rho_atom = rho_atom[0]
if not options.no_output:
fid = '%s.h5' % options.outputname
display('\nSaving to Hierarchical Data Format file (HDF5)...' +
'\n\t%(o)s' % {'o': fid})
output.hdf5_write(fid,
mode='w',
gname='',
atom=core.numpy.array(atom),
geo_info=qc.geo_info,
geo_spec=qc.geo_spec,
gross_atomic_density=rho_atom,
x=grid.x,
y=grid.y,
z=grid.z)
if not options.is_vector:
output.hdf5_write(
fid,
mode='a',
gname='/numerical_mulliken_population_analysis',
**mulliken_num)
t.append(time.time())
good_bye_message(t)
return rho_atom
if options.mo_tefd is not None:
mos = options.mo_tefd
ao_list = core.ao_creator(qc.geo_spec, qc.ao_spec)
mo_tefd = []
index = []
for i, j in mos:
mo_tefd.append([])
index.append([])
for ii_d in options.drv:
display('\nMO-TEFD: %s->%s %s-component' % (i, j, ii_d))
tefd = extras.mo_transition_flux_density(i,
j,
qc,
drv=ii_d,
ao_list=ao_list)
mo_tefd[-1].append(tefd)
index[-1].append('%s->%s:%s' % (i, j, ii_d))
if not options.no_output:
from numpy import array
fid = '%s.h5' % options.outputname
display('\nSaving to Hierarchical Data Format file (HDF5)...' +
'\n\t%(o)s' % {'o': fid})
HDF5_File = output.hdf5_open(fid, mode='w')
data = {
'geo_info': array(qc.geo_info),
'geo_spec': array(qc.geo_spec),
'mo_tefd:info': array(index),
'mo_tefd': array(mo_tefd),
'x': grid.x,
'y': grid.y,
'z': grid.z
}
output.hdf5_append(data, HDF5_File, name='')
HDF5_File.close()
t.append(time.time())
good_bye_message(t)
return mo_tefd
t.append(time.time()) # A new time step
# Compute the (derivative of the) electron density
if options.no_slice:
data = core.rho_compute_no_slice(qc,
drv=options.drv,
laplacian=options.laplacian,
return_components=False)
else:
data = core.rho_compute(qc,
drv=options.drv,
slice_length=options.slice_length,
laplacian=options.laplacian,
numproc=options.numproc)
if options.drv is None:
rho = data
elif options.laplacian:
rho, delta_rho, laplacian_rho = data
else:
rho, delta_rho = data
# Compute the reduced electron density if requested
if options.z_reduced_density:
if grid.is_vector:
display('\nSo far, reducing the density is not supported for ' +
'vector grids.\nSkipping the reduction...\n')
elif options.drv is not None:
display(
'\nSo far, reducing the density is not supported for ' +
'the derivative of the density.\nSkipping the reduction...\n')
else:
from scipy import integrate
display('\nReducing the density with respect to the z-axis.\n')
rho = integrate.simps(rho,
grid.x,
dx=grid.delta_[0],
axis=0,
even='avg')
rho = integrate.simps(rho,
grid.y,
dx=grid.delta_[1],
axis=0,
even='avg')
t.append(time.time()) # A new time step
# Generate the output requested
if not options.no_output:
output_written = output.main_output(rho,
qc.geo_info,
qc.geo_spec,
outputname=options.outputname,
otype=options.otype,
data_id='rho',
omit=['vmd', 'mayavi'],
mo_spec=qc.mo_spec)
if options.drv is not None:
output_written.extend(
output.main_output(delta_rho,
qc.geo_info,
qc.geo_spec,
outputname=options.outputname,
otype=options.otype,
data_id='delta_rho',
omit=['vmd', 'mayavi'],
mo_spec=qc.mo_spec,
drv=options.drv))
if options.laplacian:
output_written.extend(
output.main_output(laplacian_rho,
qc.geo_info,
qc.geo_spec,
outputname=options.outputname +
'_laplacian',
otype=options.otype,
data_id='laplacian_rho',
omit=['vmd', 'mayavi'],
mo_spec=qc.mo_spec))
if 'vmd' in options.otype:
# Create VMD network
display('\nCreating VMD network file...' +
'\n\t%(o)s.vmd' % {'o': options.outputname})
cube_files = []
for i in output_written:
if i.endswith('.cb'):
cube_files.append(i)
output.vmd_network_creator(options.outputname,
cube_files=cube_files)
t.append(time.time()) # Final time
good_bye_message(t)
if 'mayavi' in options.otype:
plt_data = [rho]
datalabels = ['rho']
if options.drv is not None:
plt_data.extend(delta_rho)
datalabels.extend(
['d/d%s of %s' % (ii_d, 'rho') for ii_d in options.drv])
if options.laplacian:
plt_data.append(laplacian_rho)
datalabels.append('laplacian of rho')
output.main_output(plt_data,
qc.geo_info,
qc.geo_spec,
otype='mayavi',
datalabels=datalabels)
# Return the computed data, i.e., rho for standard, and (rho,delta_rho)
# for derivative calculations. For laplacian (rho,delta_rho,laplacian_rho)
return data
Here, we implement the reduced density gradient as proposed by
Johnson et al., J. Am. Chem. Soc. 132, 6498 (2010).
'''
from orbkit import read, grid, display, core, output
'''
Identify the non-covalent interaction regions
using the reduced density gradient
'''
# open molden file and read parameters
qc = read.main_read('h2o_dimer.molden',itype='molden')
# Adjust the grid parameters to the molecular structure
grid.adjust_to_geo(qc,extend=1.0,step=0.1)
# initialize grid
grid.grid_init()
# print grid information
display.display(grid.get_grid())
# Run orbkit
rho,delta_rho = core.rho_compute(qc,drv=['x','y','z'],numproc=4)
# Compute the reduced density gradient
from numpy import sqrt,pi
s = (1./(2*(3*pi**2)**(1/3.)) * sqrt((delta_rho**2).sum(axis=0))/(rho**(4/3.)))
# Apply a density cutoff, i.e., consider only values for rho < 0.05 a.u.
s[rho>0.05] = 1e3
def run_orbkit(use_qc=None,check_options=True,standalone=False):
'''Controls the execution of all computational tasks.
**Parameters:**
use_qc : QCinfo, optional
If not None, the reading of a quantum chemistry output is omitted and
the given QCinfo class is used for all computational tasks.
(See :ref:`Central Variables` in the manual for details on QCinfo.)
check_options : bool, optional
If True, the specified options will be validated.
**Returns:**
data : type and shape depend on the options.
Contains orbkit's output.
See :ref:`High-Level Interface` in the manual for details.
'''
# Set some global variables
global qc
# Display program information
display(lgpl_short)
# Check for the correctness of orbkit.options
if check_options:
display('Checking orbkit.options...\n')
options.check_options(display=display,
interactive=False,
info=True,check_io=(use_qc is None))
# Measurement of required execution time
t=[time.time()]
# Do we need to read out the info of all MOs?
if (options.mo_set or options.calc_mo) is not False:
options.all_mo = True
if use_qc is None:
# Read the input file
qc = read.main_read(options.filename,
itype=options.itype,
all_mo=options.all_mo,
spin=options.spin,
cclib_parser=options.cclib_parser)
else:
# Use a user defined QCinfo class.
qc = use_qc
if 'native' in options.otype:
output.main_output(qc, outputname=options.outputname, otype='native', ftype=options.niotype)
options.otype.remove('native')
if not len(options.otype):
t.append(time.time()) # Final time
good_bye_message(t)
return
display('\nSetting up the grid...')
if options.grid_file is not None:
# Read the grid from an external file
grid.read(options.grid_file)
elif options.adjust_grid is not None:
# Adjust the grid to geo_spec
extend,step = options.adjust_grid
grid.adjust_to_geo(qc,extend=extend,step=step)
elif options.random_grid:
# Create a randomized grid
grid.random_grid(qc.geo_spec)
# Initialize grid
grid.grid_init(is_vector=options.is_vector)
if options.is_vector:
grid.is_regular = False
display(grid.get_grid()) # Display the grid
if not grid.is_regular and options.center_grid is not None:
raise IOError('The option --center is only supported for regular grids.')
elif options.center_grid is not None:
atom = grid.check_atom_select(options.center_grid,qc.geo_info,qc.geo_spec,
interactive=True,display=display)
# Center the grid to a specific atom and (0,0,0) if requested
grid.center_grid(qc.geo_spec[atom-1],display=display)
if check_options or standalone:
options.check_grid_output_compatibilty()
t.append(time.time()) # A new time step
# The calculation of all AOs (--calc_ao)
if options.calc_ao != False:
data = extras.calc_ao(qc,
drv=options.drv,
otype=options.otype)
t.append(time.time()) # Final time
good_bye_message(t)
return data
# The calculation of selected MOs (--calc_mo) or
# the density formed by selected MOs (--mo_set)
if (options.mo_set or options.calc_mo) != False:
# What should the program do?
if options.calc_mo != False:
fid_mo_list = options.calc_mo
elif options.mo_set != False:
fid_mo_list = options.mo_set
# Call the function for actual calculation
if options.calc_mo != False:
data = extras.calc_mo(qc,
fid_mo_list,
drv=options.drv,
otype=options.otype)
elif options.mo_set != False:
data = extras.mo_set(qc,
fid_mo_list,
drv=options.drv,
laplacian=options.laplacian,
otype=options.otype)
t.append(time.time()) # Final time
good_bye_message(t)
return data
if options.gross_atomic_density is not None:
rho_atom = extras.gross_atomic_density(options.gross_atomic_density,qc,
drv=options.drv)
if not options.no_output:
output_written = output.main_output(rho_atom,
qc,
outputname=options.outputname,
otype=options.otype)
t.append(time.time())
good_bye_message(t)
return rho_atom
t.append(time.time()) # A new time step
# Compute the (derivative of the) electron density
if options.no_slice:
data = core.rho_compute_no_slice(qc,
drv=options.drv,
laplacian=options.laplacian,
return_components = False)
else:
data = core.rho_compute(qc,
drv=options.drv,
slice_length=options.slice_length,
laplacian=options.laplacian,
numproc=options.numproc)
if options.drv is None:
rho = data
elif options.laplacian:
rho, delta_rho, laplacian_rho = data
else:
rho, delta_rho = data
t.append(time.time()) # A new time step
# Generate the output requested
if not options.no_output:
if not (options.drv is not None or options.laplacian):
plt_data = rho
datalabels = 'rho'
else:
plt_data = [rho]
datalabels = ['rho']
if options.drv is not None:
plt_data.extend(delta_rho)
datalabels.extend(['d/d%s of %s' % (ii_d,'rho') for ii_d in options.drv])
if options.laplacian:
plt_data.append(laplacian_rho)
datalabels.append('laplacian of rho')
output.main_output(plt_data,qc,outputname=options.outputname,
otype=options.otype,datalabels=datalabels)
t.append(time.time()) # Final time
good_bye_message(t)
# Return the computed data, i.e., rho for standard, and (rho,delta_rho)
# for derivative calculations. For laplacian (rho,delta_rho,laplacian_rho)
return data
# Name of input and output files
fid_in = 'h2+.molden'
# Choose the molecular orbitals to be calculated
selected_MO = ['1.1_a', '1.5_a']
# number of processes and points per process
numproc = 2
slice_length = 1e4
# Open molden file and read parameters
qc = read.main_read(fid_in, itype='molden', all_mo=True)
# Set grid parameters
grid.adjust_to_geo(qc, extend=5.0, step=0.5)
# Initialize grid
grid.grid_init()
# Print grid information
display.display(grid.get_grid())
# Choose the molecular orbitals to be calculated
selected_MO = ['1.1_a', '1.5_a']
qc.mo_spec = read.mo_select(qc.mo_spec, selected_MO, strict=True)['mo_spec']
# Calculate molecular orbitals
mo_list = core.rho_compute(qc,
calc_mo=True,
slice_length=slice_length,
drv=None,
numproc=numproc)
import os, inspect
from orbkit import read
from orbkit.core import rho_compute
from orbkit.test.tools import equal
from orbkit import grid
from orbkit import options
options.quiet = True
tests_home = os.path.dirname(inspect.getfile(inspect.currentframe()))
folder = os.path.join(tests_home, '../outputs_for_testing/molpro')
filepath = os.path.join(folder, 'h2o_rhf_sph.molden')
qc = read.main_read(filepath, all_mo=True)
grid.adjust_to_geo(qc, extend=2.0, step=1)
grid.grid_init(is_vector=False, force=True)
drv = [None, 'x', 'y', 'z', 'xx', 'xy', 'xz', 'yy', 'yz', 'zz']
data = []
for i in range(2):
if i: grid.grid2vector()
data.append([
rho_compute(qc, slice_length=0),
rho_compute(qc, numproc=options.numproc),
rho_compute(qc, laplacian=True, slice_length=0)[-1],
rho_compute(qc, laplacian=True, numproc=options.numproc)[-1],
rho_compute(qc, calc_mo=True, drv=drv, slice_length=0),
rho_compute(qc, calc_mo=True, drv=drv, numproc=options.numproc)
])