def __init__(self, restart=None, ignore_bad_restart_file=False,
label='g09', atoms=None, scratch=None, ioplist=list(),
basisfile=None, extra=None, addsec=None, **kwargs):
"""Constructs a Gaussian-calculator object.
extra: any extra text to be included in the input card
addsec: a list of strings to be included as "additional sections"
"""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
if restart is not None:
try:
self.read(restart)
except ReadError:
if ignore_bad_restart_file:
self.reset()
else:
raise
self.ioplist = ioplist
self.scratch = scratch
self.basisfile = basisfile
# store extra parameters
self.extra = extra
self.addsec = addsec
def write_input(self, atoms, properties=None, system_changes=None):
# self.Ham_AtomsDependProp(atoms)
from ase.io import write
FileIOCalculator.write_input(\
self, atoms, properties, system_changes)
self.write_dftb_in()
write('geo_end.gen', atoms)
def calculate(self, atoms=None, properties=['energy'],
system_changes=all_changes):
if 'forces' in properties:
self.parameters.task = 'gradient'
FileIOCalculator.calculate(self, atoms, properties, system_changes)
def __init__(self, label='mopac', restart=None, atoms=None, ignore_bad_restart_file=None,**kwargs):
# set initial values
self.default_parameters = dict(
restart = 0,
spin = 1,
opt = False,
functional = 'PM6',
job_type = ['NOANCI','GRADIENTS', '1SCF'],
relscf = 0.1,
charge = 0
)
# save label and atoms
self.label = label
self.atoms = atoms
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file, label, atoms, **kwargs)
#the input file written only once
# self.write_mopac_in(self.atoms)
# initialize the results
self.version = None
self.energy_zero = None
self.energy_free = None
self.forces = None
self.charges = None
self.stress = None
# initialize the results
self.occupations = None
def __init__(self, restart=None, ignore_bad_restart_file=False,
label='mopac', atoms=None, **kwargs):
"""Construct MOPAC-calculator object.
Parameters
==========
label: str
Prefix for filenames (label.mop, label.out, ...)
Examples
========
Use default values to do a single SCF calculation and print
the forces (task='1SCF GRADIENTS')
>>> from ase.build import molecule
>>> from ase.calculators.mopac import MOPAC
>>> atoms = molecule('O2')
>>> atoms.calc = MOPAC(label='O2')
>>> atoms.get_potential_energy()
>>> eigs = atoms.calc.get_eigenvalues()
>>> somos = atoms.calc.get_somo_levels()
>>> h**o, lumo = atoms.calc.get_homo_lumo_levels()
Use the internal geometry optimization of Mopac
>>> atoms = molecule('H2')
>>> atoms.calc = MOPAC(label='H2', task='GRADIENTS')
>>> atoms.get_potential_energy()
Read in and start from output file
>>> atoms = MOPAC.read_atoms('H2')
>>> atoms.calc.get_homo_lumo_levels()
"""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
def write_input(self, atoms, properties=None, system_changes=None):
FileIOCalculator.write_input(self, atoms, properties, system_changes)
p = self.parameters
# Build string to hold .mop input file:
s = p.method + ' ' + p.task + ' '
if p.relscf:
s += 'RELSCF={0} '.format(p.relscf)
# Write charge:
charge = atoms.get_initial_charges().sum()
if charge != 0:
s += 'CHARGE={0} '.format(int(round(charge)))
magmom = int(round(abs(atoms.get_initial_magnetic_moments().sum())))
if magmom:
s += (['DOUBLET', 'TRIPLET', 'QUARTET', 'QUINTET'][magmom - 1] +
' UHF ')
s += '\nTitle: ASE calculation\n\n'
# Write coordinates:
for xyz, symbol in zip(atoms.positions, atoms.get_chemical_symbols()):
s += ' {0:2} {1} 1 {2} 1 {3} 1\n'.format(symbol, *xyz)
for v, p in zip(atoms.cell, atoms.pbc):
if p:
s += 'Tv {0} {1} {2}\n'.format(*v)
with open(self.label + '.mop', 'w') as f:
f.write(s)
def __init__(self, restart=None, ignore_bad_restart_file=False,
label='gamess_us', atoms=None, delold=False, **kwargs):
"""Construct GAMESS-US-calculator object."""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
self.delold = delold
def __init__(self, restart=None, ignore_bad_restart_file=False,
label=os.curdir, atoms=None, cubes=None, radmul=None, tier=None, **kwargs):
"""Construct FHI-aims calculator.
The keyword arguments (kwargs) can be one of the ASE standard
keywords: 'xc', 'kpts' and 'smearing' or any of FHI-aims'
native keywords.
Additional arguments:
cubes: AimsCube object
Cube file specification.
radmul: int
Set radial multiplier for the basis set of all atomic species.
tier: int or array of ints
Set basis set tier for all atomic species.
"""
try:
self.outfilename = kwargs.get('run_command').split()[-1]
except:
self.outfilename = 'aims.out'
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms,
command = kwargs.get('run_command'),
**kwargs)
self.cubes = cubes
self.radmul = radmul
self.tier = tier
def write_input(self, atoms, properties=None, system_changes=None):
FileIOCalculator.write_input(self, atoms, properties,
system_changes)
struct = crys.atoms2struct(atoms)
self.cell = common.str_arr(struct.cell)
self.kpoints = pwscf.kpoints_str_pwin(kpts2mp(atoms, self.kpts))
if isinstance(self.pp, types.StringType):
pseudos = ["%s.%s" %(sym, self.pp) for sym in struct.symbols_unique]
else:
assert len(self.pp) == struct.ntypat
pseudos = []
for sym in struct.symbols_unique:
for ppi in self.pp:
if ppi.startswith(sym):
pseudos.append(ppi)
break
assert len(pseudos) == struct.ntypat
self.atspec = pwscf.atspec_str(symbols=struct.symbols_unique,
masses=struct.mass_unique,
pseudos=pseudos)
self.atpos = pwscf.atpos_str(symbols=struct.symbols,
coords=struct.coords_frac)
self.natoms = struct.natoms
self.ntyp = struct.ntypat
if self.backup:
for fn in [self.infile, self.outfile]:
if os.path.exists(fn):
common.backup(fn)
common.file_write(self.infile, self.fill_infile_templ())
def __init__(self, label='dftbddmc', atoms=None, dftbdict={}, ddmcdict={}, **kwargs):
"""Construct a DFTB+ and a dDMC calculator.
"""
os.environ['ASE_DFTBDDMC_COMMAND'] = ''
self.label = label
self.dftbdict = dftbdict
self.ddmcdict = ddmcdict
ddmc_default_parameters = {}
ddmc_default_parameters['param_a'] = 1.85705835084132
ddmc_default_parameters['param_b'] = 1.01824853175310
ddmc_default_parameters['param_c'] = 23.0
ddmc_default_parameters['dftype'] = 3
ddmc_default_parameters['tagtype'] = 'dftbp'
for param in ddmc_default_parameters.keys():
if not param in self.ddmcdict.keys():
self.ddmcdict[param] = ddmc_default_parameters[param]
restart = None
ignore_bad_restart_file = None
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
self.dftb_calc = Dftb(label=self.label)
self.ddmc_calc = dDMC(label=self.label)
def __init__(self, label='mopacddmc', atoms=None, mopacdict={}, ddmcdict={}, **kwargs):
"""Construct a MOPAC and a dDMC calculator.
"""
os.environ['ASE_MOPACDDMC_COMMAND'] = ''
self.label = label
self.mopacdict = mopacdict
self.ddmcdict = ddmcdict
ddmc_default_parameters = {}
ddmc_default_parameters['param_a'] = 1.53014262236515
ddmc_default_parameters['param_b'] = 1.04216259309481
ddmc_default_parameters['param_c'] = 23.0
ddmc_default_parameters['param_d'] = 1.84166256639050
ddmc_default_parameters['dftype'] = 4
ddmc_default_parameters['tagtype'] = 'column'
for param in ddmc_default_parameters.keys():
if not param in self.ddmcdict.keys():
self.ddmcdict[param] = ddmc_default_parameters[param]
restart = None
ignore_bad_restart_file = None
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
def read_results(self):
FileIOCalculator.read_results(self)
onetep_file = self.label + '.out'
warnings = []
try:
out = paropen(onetep_file, 'r')
except IOError:
raise ReadError('Could not open output file "%s"' % onetep_file)
line = out.readline()
while line:
if '| Total' in line:
self.results['energy'] = Hartree * float(line.split()[-2])
elif ('Element Atom Cartesian components (Eh/a)'
in line):
self._read_forces(out)
elif 'warn' in line.lower():
warnings.append(line)
line = out.readline()
if warnings:
warn('WARNING: %s contains warnings' % onetep_file)
for warning in warnings:
warn(warning)
def __init__(self,
label='ase_dftd3', # Label for dftd3 output files
command=None, # Command for running dftd3
dft=None, # DFT calculator
atoms=None,
**kwargs):
self.dft = None
FileIOCalculator.__init__(self, restart=None,
ignore_bad_restart_file=False,
label=label,
atoms=atoms,
command=command,
dft=dft,
**kwargs)
# If the user is running DFTD3 with another DFT calculator, such as
# GPAW, the DFT portion of the calculation should take much longer.
# If we only checked for a valid command in self.calculate, the DFT
# calculation would run before we realize that we don't know how
# to run dftd3. So, we check here at initialization time, to avoid
# wasting the user's time.
if self.command is None:
raise RuntimeError("Don't know how to run DFTD3! Please "
'set the ASE_DFTD3_COMMAND environment '
'variable, or explicitly pass the path '
'to the dftd3 executable to the D3 calculator!')
if isinstance(self.command, str):
self.command = self.command.split()
def write_input(self, atoms, properties=None, system_changes=None):
FileIOCalculator.write_input(self, atoms, properties=properties,
system_changes=system_changes)
txt = generate_input(atoms, self.kwargs)
fd = open(self._getpath('inp'), 'w')
fd.write(txt)
fd.close()
def write_input(self, atoms, properties=None, system_changes=None):
FileIOCalculator.write_input(self, atoms, properties, system_changes)
p = self.parameters
# Build string to hold .gin input file:
s = p.keywords
s += '\ntitle\nASE calculation\nend\n\n'
if all(self.atoms.pbc):
cell_params = self.atoms.get_cell_lengths_and_angles()
s += 'cell\n{0} {1} {2} {3} {4} {5}\n'.format(*cell_params)
s += 'frac\n'
coords = self.atoms.get_scaled_positions()
else:
s += 'cart\n'
coords = self.atoms.get_positions()
if self.conditions is not None:
c = self.conditions
labels = c.get_atoms_labels()
self.atom_types = c.get_atom_types()
else:
labels = self.atoms.get_chemical_symbols()
for xyz, symbol in zip(coords, labels):
s += ' {0:2} core {1} {2} {3}\n'.format(symbol, *xyz)
if symbol in p.shel:
s += ' {0:2} shel {1} {2} {3}\n'.format(symbol, *xyz)
s += '\nlibrary {0}\n'.format(p.library)
if p.options:
for t in p.options:
s += '%s\n' % t
with open(self.prefix + '.gin', 'w') as f:
f.write(s)
def calculate(self,
atoms=None,
properties=['energy'],
system_changes=all_changes):
"""Capture the RuntimeError from FileIOCalculator.calculate
and add a little debug information from the Siesta output.
See base FileIocalculator for documentation.
"""
try:
FileIOCalculator.calculate(
self,
atoms=atoms,
properties=properties,
system_changes=system_changes)
# Here a test to check if the potential are in the right place!!!
except RuntimeError as e:
try:
with open(self.label + '.out', 'r') as f:
lines = f.readlines()
debug_lines = 10
print('##### %d last lines of the Siesta output' % debug_lines)
for line in lines[-20:]:
print(line.strip())
print('##### end of siesta output')
raise e
except:
raise e
def __init__(self, restart=None, ignore_bad_restart_file=False,
label='abinit', atoms=None, scratch=None, **kwargs):
"""Construct ABINIT-calculator object.
Parameters
==========
label: str
Prefix to use for filenames (label.in, label.txt, ...).
Default is 'abinit'.
Examples
========
Use default values:
>>> h = Atoms('H', calculator=Abinit(ecut=200, toldfe=0.001))
>>> h.center(vacuum=3.0)
>>> e = h.get_potential_energy()
"""
self.scratch = scratch
self.species = None
self.ppp_list = None
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
def write_input(self, atoms=None, properties=None, system_changes=None):
"""
Write input file(s). This is called by FileIOCalculator just before
it executes the external command.
"""
# This is restarted calculation do not write anything.
if self.restart : return
self.set(prefix=self.prefix)
self.atoms2params()
FileIOCalculator.write_input(self, atoms, properties, system_changes)
if set(['energy','stress','forces','bands','edos']) & set(properties) :
write_pw_in(self.directory, atoms, self.parameters)
if 'bands' in properties :
write_bands_in(self.directory, atoms, self.parameters)
if 'edos' in properties:
write_edos_in(self.directory, atoms, self.parameters)
if 'd2' in properties :
write_ph_in(self.directory, atoms, self.parameters)
write_q2r_in(self.directory, atoms, self.parameters)
if 'frequencies' in properties :
write_matdyn_in(self.directory, atoms, self.parameters)
if 'phdos' in properties:
write_phdos_in(self.directory, atoms, self.parameters)
def __init__(self, restart=None, ignore_bad_restart_file=False,
label='dmol_calc/tmp', atoms=None, **kwargs):
""" Construct DMol3 calculator. """
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
# tracks if DMol transformed coordinate system
self.internal_transformation = False
def __init__(self,
restart=None,
label=None,
atoms=None,
command='octopus',
ignore_troublesome_keywords=None,
check_keywords=True,
_autofix_outputformats=False,
**kwargs):
"""Create Octopus calculator.
Label is always taken as a subdirectory.
Restart is taken to be a label."""
# XXX support the specially defined ASE parameters,
# "smear" etc.
# We run oct-help to get a list of all keywords.
# This makes us able to robustly construct the input file
# in the face of changing octopus versions, and also of
# early partial verification of user input.
if check_keywords:
try:
octopus_keywords = get_octopus_keywords()
except OSError as err:
msg = ('Could not obtain Octopus keyword list from '
'command oct-help: %s. Octopus not installed in '
'accordance with expectations. '
'Use check_octopus_keywords=False to override.' % err)
raise OSError(msg)
else:
octopus_keywords = None
self.octopus_keywords = octopus_keywords
self._autofix_outputformats = _autofix_outputformats
if restart is not None:
if label is not None and restart != label:
raise ValueError('restart and label are mutually exclusive '
'or must at the very least coincide.')
label = restart
if label is None:
label = 'ink-pool'
if ignore_troublesome_keywords:
trouble = set(self.troublesome_keywords)
for keyword in ignore_troublesome_keywords:
trouble.remove(keyword)
self.troublesome_keywords = trouble
self.kwargs = {}
FileIOCalculator.__init__(self, restart=restart,
ignore_bad_restart_file=False,
label=label,
atoms=atoms,
command=command, **kwargs)
def read_results(self):
FileIOCalculator.read(self, self.label)
if not os.path.isfile(self.label + '.got'):
raise ReadError
with open(self.label + '.got') as f:
lines = f.readlines()
cycles = -1
self.optimized = None
for i, line in enumerate(lines):
m = re.match(r'\s*Total lattice energy\s*=\s*(\S+)\s*eV', line)
if m:
energy = float(m.group(1))
self.results['energy'] = energy
self.results['free_energy'] = energy
elif line.find('Optimisation achieved') != -1:
self.optimized = True
elif line.find('Final Gnorm') != -1:
self.Gnorm = float(line.split()[-1])
elif line.find('Cycle:') != -1:
cycles += 1
elif line.find('Final Cartesian derivatives') != -1:
s = i + 5
forces = []
while(True):
s = s + 1
if lines[s].find("------------") != -1:
break
if lines[s].find(" s ") != -1:
continue
g = lines[s].split()[3:6]
G = [-float(x) * eV / Ang for x in g]
forces.append(G)
forces = np.array(forces)
self.results['forces'] = forces
elif line.find('Final cartesian coordinates of atoms') != -1:
s = i + 5
positions = []
while True:
s = s + 1
if lines[s].find("------------") != -1:
break
if lines[s].find(" s ") != -1:
continue
xyz = lines[s].split()[3:6]
XYZ = [float(x) * Ang for x in xyz]
positions.append(XYZ)
positions = np.array(positions)
self.atoms.set_positions(positions)
self.steps = cycles
def read(self, label):
FileIOCalculator.read(self, label)
if not os.path.isfile(self.label + '.out'):
raise ReadError
self.parameters = Parameters.read(self.label + '.ase')
self.atoms = read_gamess_us_input(self.label + '.inp')
self.read_results()
def __init__(self, restart=None, ignore_bad_restart_file=False,
label='dftb', atoms=None, kpts=None,
**kwargs):
"""Construct a DFTB+ calculator.
"""
from ase.dft.kpoints import monkhorst_pack
if 'DFTB_PREFIX' in os.environ:
slako_dir = os.environ['DFTB_PREFIX']
else:
slako_dir = './'
self.default_parameters = dict(
Hamiltonian_='DFTB',
Driver_='ConjugateGradient',
Driver_MaxForceComponent='1E-4',
Driver_ConvergentForcesOnly = 'No',
Driver_MaxSteps=0,
Hamiltonian_SlaterKosterFiles_='Type2FileNames',
Hamiltonian_SlaterKosterFiles_Prefix=slako_dir,
Hamiltonian_SlaterKosterFiles_Separator='"-"',
Hamiltonian_SlaterKosterFiles_Suffix='".skf"',
Hamiltonian_SCC = 'No',
Hamiltonian_Eigensolver = 'RelativelyRobust{}'
)
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
self.kpts = kpts
# kpoint stuff by ase
if self.kpts != None:
mpgrid = kpts2mp(atoms, self.kpts)
mp = monkhorst_pack(mpgrid)
initkey = 'Hamiltonian_KPointsAndWeights'
self.parameters[initkey + '_'] = ''
for i, imp in enumerate(mp):
key = initkey + '_empty' + str(i)
self.parameters[key] = str(mp[i]).strip('[]') + ' 1.0'
#the input file written only once
if restart == None:
self.write_dftb_in()
else:
if os.path.exists(restart):
os.system('cp ' + restart + ' dftb_in.hsd')
if not os.path.exists('dftb_in.hsd'):
raise IOError('No file "dftb_in.hsd", use restart=None')
#indexes for the result file
self.first_time = True
self.index_energy = None
self.index_force_begin = None
self.index_force_end = None
self.index_charge_begin = None
self.index_charge_end = None
def __init__(self, **kwargs):
parameters = self.get_default_parameters()
functional, authors = parameters['xc'].split('.')
parameters['xc'] = XC(functional=functional, authors=authors)
parameters.update(kwargs)
FileIOCalculator.__init__(
self,
**parameters
)
def run_calculation(self, atoms, properties, system_changes):
'''
Hook for the more involved remote calculator to link into.
Actually invokes the parent calculation routine.
'''
# This is restarted calculation do not write anything.
# Nothing to do - just return.
if self.restart : return
FileIOCalculator.calculate(self, atoms, properties, system_changes)
def calculate(self, atoms, properties=['energy'], system_changes=[]):
""" overrides parent calculate() method for testing reason
should not be in prod. version """
try:
FileIOCalculator.calculate(self, atoms, properties, system_changes)
#~ self.read_results() # to test
#~ self.results['energy'] = self.residual() # to test
except RuntimeError:
print('ERROR: RuntimeError')
self.results['energy'] = 999 # big value
def read(self, label):
"""Read a onetep .out file into the current instance."""
FileIOCalculator.read(self, label)
onetep_file = self.label + '.out'
warnings = []
try:
out = paropen(onetep_file, 'r')
except IOError:
raise ReadError('Could not open output file "%s"' % onetep_file)
# keep track of what we've read in
read_lattice = False
read_species = False
read_positions = False
line = out.readline()
if self.atoms is None:
self.atoms = Atoms()
self.atoms.calc = self
while line:
clean_line = line.strip().lower()
if '%block lattice_cart' in clean_line:
self._read_lattice(out)
read_lattice = True
elif '%block species_pot' in clean_line:
self._read_species_pot(out)
elif '%block species' in clean_line:
self._read_species(out)
read_species = True
elif '%block positions_abs' in clean_line:
self._read_positions(out)
read_positions = True
elif '%block species_cond' in clean_line:
self._read_species_cond(out)
elif 'warn' in line.lower():
warnings.append(line)
line = out.readline()
out.close()
if warnings:
warn('WARNING: %s contains warnings' % onetep_file)
for warning in warnings:
warn(warning)
if not (read_lattice and read_species and read_positions):
raise ReadError('Failed to read in essential calculation'
' data from output file "%s"' % onetep_file)
self.read_results(label)
def __init__(self, restart=None, ignore_bad_restart_file=False,
label='abinit', atoms=None, scratch=None, **kwargs):
"""Construct ABINIT-calculator object.
Parameters
==========
label: str
Prefix to use for filenames (label.in, label.txt, ...).
Default is 'abinit'.
xc: str
Exchange-correlation functional. Must be one of LDA, PBE,
revPBE, RPBE.
kpts: list of three int
Monkhost-Pack sampling.
nbands: int
Number of bands.
For the values of occopt not equal to 0 or 2, nbands can be omitted.
nstep: int
Number of self-consistent field STEPS.
width: float
Fermi-distribution width in eV.
Default is 0.04 Hartree.
ecut: float
Planewave cutoff energy in eV.
No default.
charge: float
Total charge of the system.
Default is 0.
npulayit: int
Number of old densities to use for Pulay mixing.
diemix: float
Mixing parameter between zero and one for density mixing.
diemac: float
Model DIElectric MACroscopic constant.
The value of diemac should usually be bigger than 1.0d0,
on physical grounds. If you let diemac to its default value,
you might even never obtain the self-consistent convergence!
Examples
========
Use default values:
>>> h = Atoms('H', calculator=Abinit(ecut=200, toldfe=0.001))
>>> h.center(vacuum=3.0)
>>> e = h.get_potential_energy()
"""
self.scratch = scratch
self.species = None
self.ppp_list = None
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
def __init__(self, restart=None, ignore_bad_restart_file=False,
label=os.curdir, atoms=None, **kwargs):
"""Construct ELK calculator.
The keyword arguments (kwargs) can be one of the ASE standard
keywords: 'xc', 'kpts' and 'smearing' or any of ELK'
native keywords.
"""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
def write_input(self, atoms, properties=None, system_changes=None):
"""Write input (fdf)-file.
See calculator.py for further details.
Parameters:
- atoms : The Atoms object to write.
- properties : The properties which should be calculated.
- system_changes : List of properties changed since last run.
"""
# Call base calculator.
FileIOCalculator.write_input(
self,
atoms=atoms,
properties=properties,
system_changes=system_changes)
if system_changes is None and properties is None:
return
filename = self.label + '.fdf'
# On any changes, remove all analysis files.
if system_changes is not None:
self.remove_analysis()
# Start writing the file.
with open(filename, 'w') as f:
# First write explicitly given options to
# allow the user to overwrite anything.
self._write_fdf_arguments(f)
# Use the saved density matrix if only 'cell' and 'positions'
# haved changes.
if (system_changes is None or
('numbers' not in system_changes and
'initial_magmoms' not in system_changes and
'initial_charges' not in system_changes)):
f.write(format_fdf('DM.UseSaveDM', True))
# Save density.
if 'density' in properties:
f.write(format_fdf('SaveRho', True))
# Write system name and label.
f.write(format_fdf('SystemName', self.label))
f.write(format_fdf('SystemLabel', self.label))
# Force siesta to return error on no convergence.
f.write(format_fdf('SCFMustConverge', True))
# Write the rest.
self._write_species(f, atoms)
self._write_kpts(f)
self._write_structure(f, atoms)
def __init__(self, **kwargs):
"""ASE interface to the deMon code.
Parameters:
label : str. relative path to the run directory
atoms : The Atoms onject
command : str. Command to run deMon. If not present the environment varable DEMON_COMMAND will be used
restart : str. Relative path to ASE restart directory for parameters and atoms object and results
basis_path : str. Relative path to the directory containing BASIS, AUXIS, ECPS, MCPS and AUGMENT
ignore_bad_restart_file : bool. Ignore broken or missing ASE restart files
By default, it is an error if the restart
file is missing or broken.
deMon_restart_path : str. Relative path to the deMon restart dir
title : str. Title in the deMon input file.
scftype : str. Type of scf
forces : bool. If True a force calculation will be enforced.
dipole : bool. If True a dipole calculation will be enforced
xc : str. xc-functional
guess : str. guess for initial density and wave functions
print_out : str|list. Options for the printing in deMon
basis : dict. Definition of basis sets.
ecps : dict. Definition of ECPs.
mcps : dict. Definition of MCPs.
auxis : dict. Definition of AUXIS,
augment : dict. Definition of AUGMENT.
input_arguments: dict. Explicitly given input arguments. The key is the input keyword
and the value is either a str, a list of str (will be written on the same line as the keyword),
or a list of lists of str (first list is written on the first line, the others on following lines.)
"""
parameters = Parameters_deMon(**kwargs)
# Setup the run command
command = parameters['command']
if command is None:
command = os.environ.get('DEMON_COMMAND')
if command is None:
mess = 'The "DEMON_COMMAND" environment is not defined.'
raise ValueError(mess)
else:
parameters['command'] = command
# Call the base class.
FileIOCalculator.__init__(self, **parameters)
def check_state(self, atoms):
system_changes = FileIOCalculator.check_state(self, atoms)
# Ignore unit cell and boundary conditions:
if 'cell' in system_changes:
system_changes.remove('cell')
if 'pbc' in system_changes:
system_changes.remove('pbc')
return system_changes
def read(self, label=None):
if label is None:
label = self.label
FileIOCalculator.read(self, label)
geometry = os.path.join(self.directory, 'geometry.in')
control = os.path.join(self.directory, 'control.in')
for filename in [geometry, control, self.out]:
if not os.path.isfile(filename):
raise ReadError
self.atoms, symmetry_block = read_aims(geometry, True)
self.parameters = Parameters.read(
os.path.join(self.directory, 'parameters.ase'))
if symmetry_block:
self.parameters["symmetry_block"] = symmetry_block
self.read_results()
def write_input(self, atoms, properties=None, system_changes=None):
'''Initializes input parameters and xyz files. If force calculation is requested, add Force section to parameters if not exists.
Parameters
==========
atoms: ASE atoms object.
properties: List of properties to be calculated. Should be element of self.implemented_properties.
system_chages: Ignored.
'''
FileIOCalculator.write_input(self, atoms, properties, system_changes)
with open(self.label + '.inp', 'w') as inputfile:
xyz_name = "{}.xyz".format(self.label)
atoms.write(xyz_name)
run_parameters = self.prepare_input(xyz_name, properties)
self.write_acemolecule_input(inputfile, run_parameters)
def read(self, label):
FileIOCalculator.read(self, label)
filename = self.label + ".log"
with open(filename, 'r') as fd:
lines = fd.readlines()
if 'WARNING' in lines:
raise ReadError(
"Not convergy energy in log file {}.".format(filename))
if '! total energy' not in lines:
raise ReadError("Wrong ACE-Molecule log file {}.".format(filename))
if not os.path.isfile(filename):
raise ReadError(
"Wrong ACE-Molecule input file {}.".format(filename))
self.read_results()
def check_state(self, atoms):
system_changes = FileIOCalculator.check_state(self, atoms)
# Ignore unit cell for molecules:
if not atoms.pbc.any() and 'cell' in system_changes:
system_changes.remove('cell')
if self.pcpot and self.pcpot.mmpositions is not None:
system_changes.append('positions')
return system_changes
def __init__(self, restart=None, ignore_bad_restart_file=False,
label=os.curdir, atoms=None, cubes=None, **kwargs):
"""Construct FHI-aims calculator.
The keyword arguments (kwargs) can be one of the ASE standard
keywords: 'xc', 'kpts' and 'smearing' or any of FHI-aims'
native keywords.
Additional arguments:
cubes: AimsCube object
Cube file specification.
"""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
self.cubes = cubes
def write_input(self, atoms=None, properties=None, system_changes=None):
"""Write input parameters to input file."""
FileIOCalculator.write_input(self, atoms, properties, system_changes)
#print self.parameters
myfile = open(self.label + '.mdp', 'w')
for key, val in self.parameters.items():
if val is not None:
if (self.params_doc.get(key) == None):
docstring = ''
else:
docstring = self.params_doc[key]
myfile.write('%-35s = %s ; %s\n' \
% (key, val, ';' + docstring))
myfile.close()
if self.freeze_qm:
self.add_freeze_group()
def __init__(self,
restart=None,
ignore_bad_restart_file=FileIOCalculator._deprecated,
label='./openmx',
atoms=None,
command=None,
mpi=None,
pbs=None,
**kwargs):
# Initialize and put the default parameters.
self.initialize_pbs(pbs)
self.initialize_mpi(mpi)
self.initialize_output_setting(**kwargs)
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, command, **kwargs)
def __init__(self, restart=None, ignore_bad_restart_file=False,
label='qchem', scratch=None, np=1, nt=1, pbs=False,
basisfile=None, ecpfile=None, atoms=None, **kwargs):
"""
The scratch directory, number of processor and threads as well as a few
other command line options can be set using the arguments explained
below. The remaining kwargs are copied as options to the input file.
The calculator will convert these options to lower case for storage
and convert back to upper case (Q-Chem standard) when writing the
input file.
scratch: str
path of the scratch directory
np: int
number of processors for the -np command line flag
nt: int
number of threads for the -nt command line flag
pbs: boolean
command line flag for pbs scheduler (see Q-Chem manual)
basisfile: str
path to file containing the basis. Use in combination with
basis='gen' keyword argument.
ecpfile: str
path to file containing the effective core potential. Use in
combination with ecp='gen' keyword argument.
"""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
# Augment the command by various flags
if pbs:
self.command = 'qchem -pbs '
else:
self.command = 'qchem '
if np != 1:
self.command += '-np %d ' % np
if nt != 1:
self.command += '-nt %d ' % nt
self.command += 'PREFIX.inp PREFIX.out'
if scratch is not None:
self.command += ' %s' % scratch
self.basisfile = basisfile
self.ecpfile = ecpfile
def write_input(self, atoms, properties=None, system_changes=None):
"""Write input parameters to in.pmd file."""
FileIOCalculator.write_input(self, atoms, properties, system_changes)
if self.label == 'pmd':
infname = 'in.pmd'
# write_pmd(atoms,fname='pmdini',specorder=self.specorder)
nsys = NAPSystem.from_ase_atoms(atoms, specorder=self.specorder)
nsys.write_pmd(fname='pmdini')
with open(infname, 'w') as f:
fmvs, ifmvs = get_fmvs(atoms)
for i in range(len(fmvs)):
for ii in range(3):
if fmvs[i][ii] > 0.1 and not self.dimension[ii]:
fmvs[i][ii] = 0.0
f.write(get_input_txt(self.parameters, fmvs))
def check_state(self, atoms):
system_changes = FileIOCalculator.check_state(self, atoms)
ignore = ['cell', 'pbc']
for change in system_changes:
if change in ignore:
system_changes.remove(change)
return system_changes
def __init__(self,
restart=None,
ignore_bad_restart_file=False,
label=os.curdir,
atoms=None,
**kwargs):
""" Constructor """
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
valid_args = ('atoms', 'fods', 'SYMBOL', 'ISYMGEN', 'basis', 'e_up',
'e_dn', 'calc', 'mode', 'xc', 'extra', 'FRMORB')
# set any additional keyword arguments
for arg, val in self.parameters.items():
if arg in valid_args:
setattr(self, arg, val)
else:
raise RuntimeError('unknown keyword arg "%s" : not in %s' %
(arg, valid_args))
def write_input(self, atoms, properties=None, system_changes=None):
FileIOCalculator.write_input(self, atoms, properties, system_changes)
# Prepare perm and scratch directories
perm = os.path.abspath(self.parameters.get('perm', self.label))
scratch = os.path.abspath(self.parameters.get('scratch', self.label))
os.makedirs(perm, exist_ok=True)
os.makedirs(scratch, exist_ok=True)
#io.write(self.label + '.nwi', atoms, properties=properties,
# label=self.label, **self.parameters)
fd = open(self.label + '.nwi', 'w')
write_nwchem_in(fd,
atoms,
properties=properties,
label=self.label,
**self.parameters)
fd.close()
def write_input(self,
atoms,
properties=None,
system_changes=None,
ghosts=None):
FileIOCalculator.write_input(self, atoms, properties, system_changes)
have_lattice_vectors = atoms.pbc.any()
have_k_grid = ('k_grid' in self.parameters
or 'kpts' in self.parameters)
if have_lattice_vectors and not have_k_grid:
raise RuntimeError('Found lattice vectors but no k-grid!')
if not have_lattice_vectors and have_k_grid:
raise RuntimeError('Found k-grid but no lattice vectors!')
write_aims(os.path.join(self.directory, 'geometry.in'), atoms, ghosts)
self.write_control(atoms, os.path.join(self.directory, 'control.in'))
self.write_species(atoms, os.path.join(self.directory, 'control.in'))
self.parameters.write(os.path.join(self.directory, 'parameters.ase'))
def __init__(self,
restart=None,
ignore_bad_restart_file=False,
label='wannier',
atoms=None,
**kwargs):
"""
All options for wannier90 are copied verbatim to the input file
"""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
if atoms is not None:
self.atoms = atoms
self.atoms.calc = self
self.calc = None
def set(self, **kwargs):
xc = kwargs.get('xc')
if xc:
kwargs['xc'] = {'LDA': 'pw-lda', 'PBE': 'pbe'}.get(xc, xc)
changed_parameters = FileIOCalculator.set(self, **kwargs)
if changed_parameters:
self.reset()
return changed_parameters
def write_input(self, atoms, properties=None, system_changes=None):
from ase.io import write
# print("Calculated Properties: ...", properties)
# if properties is not None:
# if 'forces' in properties or 'stress' in properties:
# self.do_forces = True
self.do_forces = True
FileIOCalculator.write_input(self, atoms, properties, system_changes)
self.write_dftb_in(os.path.join(self.directory, 'dftb_in.hsd'))
write(os.path.join(self.directory, self.geo_fname), atoms)
# self.atoms is none until results are read out,
# then it is set to the ones at writing input
self.atoms_input = atoms
self.atoms = None
# jx: !!!
if self.pcpot:
self.pcpot.write_mmcharges('dftb_external_charges.dat')
return
def read(self, label):
# XXX label of restart file may not be the same as actual label!
# This makes things rather tricky. We first set the label to
# that of the restart file and arbitrarily expect the remaining code
# to rectify any consequent inconsistencies.
self.set_label(label)
FileIOCalculator.read(self, label)
inp_path = self._getpath('inp')
fd = open(inp_path)
kwargs = parse_input_file(fd)
if self.octopus_keywords is not None:
self.check_keywords_exist(kwargs)
self.atoms, kwargs = kwargs2atoms(kwargs)
self.kwargs.update(kwargs)
fd.close()
self.read_results()
def __init__(self,
restart=None,
ignore_bad_restart_file=FileIOCalculator._deprecated,
label=None,
command=None,
atoms=None,
**kwargs):
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, command, **kwargs)
self.species = []
self.species_cond = []
self.pseudos = []
self.core_wfs = []
self.solvers = []
self.solvers_cond = []
self.restart = False
self.prefix = label
self.directory = '.'
def get_hirsh_charges(self):
"""
return atomic charges as obtained by Hirshfeld analysis
by Martin Stoehr ([email protected]) Oct 2015
"""
atoms = self.atoms
if ('output' in self.parameters
and 'hirshfeld' not in self.parameters['output']):
raise NotImplementedError
return FileIOCalculator.get_property(self, 'hirsh_charges', atoms)
def __init__(self,
restart=None,
ignore_bad_restart_file=False,
label='g09',
atoms=None,
scratch=None,
ioplist=list(),
basisfile=None,
**kwargs):
"""Constructs a Gaussian-calculator object.
"""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
self.ioplist = ioplist
self.scratch = scratch
self.basisfile = basisfile
def calculate(self,
atoms=None,
properties=['energy'],
system_changes=all_changes):
"""Capture the RuntimeError from FileIOCalculator.calculate
and add a little debug information from the Siesta output.
See base FileIocalculator for documentation.
"""
FileIOCalculator.calculate(self,
atoms=atoms,
properties=properties,
system_changes=system_changes)
# The below snippet would run if calculate() failed but I have
# disabled it for now since it looks to be just for debugging.
# --askhl
"""
def __init__(self,
restart=None,
ignore_bad_restart_file=False,
label='gulp',
atoms=None,
optimized=None,
Gnorm=1000.0,
steps=1000,
conditions=None,
**kwargs):
"""Construct GULP-calculator object."""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
self.optimized = optimized
self.Gnorm = Gnorm
self.steps = steps
self.conditions = conditions
self.library_check()
self.atom_types = []
def __init__(
self,
label='ase_dftd3', # Label for dftd3 output files
command=None, # Command for running dftd3
dft=None, # DFT calculator
atoms=None,
comm=world,
**kwargs):
self.dft = None
FileIOCalculator.__init__(self,
restart=None,
label=label,
atoms=atoms,
command=command,
dft=dft,
**kwargs)
self.comm = comm
def calculate(self, *args, **kwargs):
gaussians = ('g16', 'g09', 'g03')
if 'GAUSSIAN' in self.command:
for gau in gaussians:
if which(gau):
self.command = self.command.replace('GAUSSIAN', gau)
break
else:
#raise EnvironmentError('Missing Gaussian executable {}'
#.format(gaussians))
pass
try:
FileIOCalculator.calculate(self, *args, **kwargs)
except:
print('Gaussian error')
i = 0
while Path('gauserror' + str(i) + '.log').exists():
i += 1
copyfile(self.label + '.log', 'gauserror' + str(i) + '.log')
def get_mull_charges(self):
"""
return atomic charges as obtained by Mulliken analysis
by Martin Stoehr ([email protected]) Oct 2015
"""
atoms = self.atoms
if ('output' in self.parameters
and 'mulliken' not in self.parameters['output']):
raise NotImplementedError('Tell AIMS to do Mulliken analysis!')
return FileIOCalculator.get_property(self, 'mull_charges', atoms)
def write_input(self, atoms, properties=None, system_changes=None):
if not (np.all(atoms.pbc) or not np.any(atoms.pbc)):
raise RuntimeError('PBC must be all true or all false')
self.clean() # Remove files from old run
self.internal_transformation = False
self.ase_positions = atoms.positions.copy()
self.ase_cell = atoms.cell.copy()
FileIOCalculator.write_input(self, atoms, properties, system_changes)
if np.all(atoms.pbc):
write_dmol_incoor(self.label + '.incoor', atoms)
elif not np.any(atoms.pbc):
write_dmol_car(self.label + '.car', atoms)
self.write_input_file()
self.parameters.write(self.label + '.parameters.ase')
def read_results(self):
FileIOCalculator.read(self, self.label)
if not os.path.isfile(self.label + '.out'):
raise ReadError
with open(self.label + '.out') as f:
lines = f.readlines()
for i, line in enumerate(lines):
if line.find('TOTAL ENERGY') != -1:
self.results['energy'] = float(line.split()[3])
elif line.find('FINAL POINT AND DERIVATIVES') != -1:
forces = [
-float(line.split()[6])
for line in lines[i + 3:i + 3 + 3 * len(self.atoms)]
]
forces = np.array(forces).reshape((-1, 3)) * kcal / mol
self.results['forces'] = forces
break
def __init__(self,
restart=None,
ignore_bad_restart_file=False,
label='ase/tmp_ase',
atoms=None,
scratch=None,
ioplist=list(),
basisfile=None,
extra=None,
addsec=None,
command=None,
**kwargs):
"""Constructs a Gaussian-calculator object.
extra: any extra text to be included in the input card
addsec: a list of strings to be included as "additional sections"
"""
FileIOCalculator.__init__(self, restart, ignore_bad_restart_file,
label, atoms, **kwargs)
if restart is not None:
try:
self.read(restart)
except ReadError:
if ignore_bad_restart_file:
self.reset()
else:
raise
self.ioplist = ioplist
self.scratch = scratch
self.basisfile = basisfile
# store extra parameters
self.extra = extra
self.addsec = addsec
self.forces = None
self.energy_free = None
if command: self.command = command
