def __init__(
self,
label='rundir',
atoms=None,
command=None,
restart=None,
basis_path=None,
ignore_bad_restart_file=False,
deMon_restart_path='.',
title='deMon input file',
scftype='RKS',
forces=False,
dipole=False,
xc='VWN',
guess='TB',
print_out='MOE',
basis={},
ecps={},
mcps={},
auxis={},
augment={},
input_arguments=None):
kwargs = locals()
kwargs.pop('self')
Parameters.__init__(self, **kwargs)
def attach_model(self,
model,
images=None,
fingerprints=None,
fingerprintprimes=None,
log=None):
"""Attach the model to be used to the loss function.
hashed images, fingerprints and fingerprintprimes can optionally be
specified; this is typically for use in parallelization.
Parameters
----------
model : object
Class representing the regression model.
images : dict
Dictionary of hashed images to train on.
fingerprints : dict
Fingerprints of images to train on.
fingerprintprimes : dict
Fingerprint derivatives of images to train on.
"""
self._model = model
if not hasattr(self._model, 'trainingparameters'):
self._model.trainingparameters = Parameters()
self._model.trainingparameters.descriptor = Parameters()
if images is not None:
self._model.trainingparameters.images = images
descriptor = self._model.trainingparameters.descriptor
if fingerprints is not None:
descriptor.fingerprints = fingerprints
if fingerprintprimes is not None:
descriptor.fingerprintprimes = fingerprintprimes
if log is not None:
self.log = log
def __init__(
self,
label='rundir',
atoms=None,
command=None,
restart=None,
basis_path=None,
ignore_bad_restart_file=False,
deMon_restart_path='.',
title='deMon input file',
scftype='RKS',
forces=False,
dipole=False,
xc='VWN',
guess='TB',
print_out='MOE',
basis={},
ecps={},
mcps={},
auxis={},
augment={},
input_arguments=None):
kwargs = locals()
kwargs.pop('self')
Parameters.__init__(self, **kwargs)
def save(self, filename, overwrite=False):
"""Saves the calculator in a way that it can be re-opened with
load.
Parameters
----------
filename : str
File object or path to the file to write to.
overwrite : bool
If an output file with the same name exists, overwrite it.
"""
if os.path.exists(filename):
if overwrite is False:
oldfilename = filename
filename = tempfile.NamedTemporaryFile(mode='w',
delete=False,
suffix='.amp').name
self._log('File "%s" exists. Instead saving to "%s".' %
(oldfilename, filename))
else:
oldfilename = tempfile.NamedTemporaryFile(mode='w',
delete=False,
suffix='.amp').name
self._log('Overwriting file: "%s". Moving original to "%s".' %
(filename, oldfilename))
shutil.move(filename, oldfilename)
descriptor = self.descriptor.tostring()
model = self.model.tostring()
p = Parameters({'descriptor': descriptor, 'model': model})
p.write(filename)
return filename
def __init__(self, neighborlist, anotherparamter, cutoff, cutofffn):
self.globals = Parameters({
'cutoff': cutoff,
'cutofffn': cutofffn,
'anotherparameter': anotherparamter
})
self.keyed = Parameters({'neighborlist': neighborlist})
self.parallel_command = 'calculate_fingerprints'
def __init__(self,
symbol,
basis_set='DZP',
pseudopotential=None,
tag=None,
ghost=False):
kwargs = locals()
kwargs.pop('self')
Parameters.__init__(self, **kwargs)
def __init__(self,
symbol,
basis_set='DZP',
pseudopotential=None,
tag=None,
ghost=False,
excess_charge=None):
kwargs = locals()
kwargs.pop('self')
Parameters.__init__(self, **kwargs)
def __init__(self,
label='.',
atoms=None,
command=None,
basis_path=None,
restart_path='.',
print_out='ASE',
title='deMonNano input file',
forces=False,
input_arguments=None):
kwargs = locals()
kwargs.pop('self')
Parameters.__init__(self, **kwargs)
def __init__(self, neighborlist, Gs, nmax, cutoff, fortran):
self.globals = Parameters({'cutoff': cutoff, 'Gs': Gs, 'nmax': nmax})
self.keyed = Parameters({'neighborlist': neighborlist})
self.parallel_command = 'calculate_fingerprint_primes'
self.fortran = fortran
try: # for scipy v <= 0.90
from scipy import factorial as fac
except ImportError:
try: # for scipy v >= 0.10
from scipy.misc import factorial as fac
except ImportError: # for newer version of scipy
from scipy.special import factorial as fac
self.factorial = [fac(0.5 * _) for _ in range(4 * nmax + 3)]
def __init__(
self,
neighborlist,
Gs,
jmax,
cutoff,
):
self.globals = Parameters({'cutoff': cutoff, 'Gs': Gs, 'jmax': jmax})
self.keyed = Parameters({'neighborlist': neighborlist})
self.parallel_command = 'calculate_fingerprints'
self.factorial = [1]
for _ in range(int(3. * jmax) + 2):
if _ > 0:
self.factorial += [_ * self.factorial[_ - 1]]
def set(self, **kwargs):
"""Set parameters like set(key1=value1, key2=value2, ...).
A dictionary containing the parameters that have been changed
is returned.
The special keyword 'parameters' can be used to read
parameters from a file."""
if 'parameters' in kwargs:
filename = kwargs.pop('parameters')
parameters = Parameters.read(filename)
parameters.update(kwargs)
kwargs = parameters
changed_parameters = {}
for key, value in kwargs.items():
oldvalue = self.parameters.get(key)
if key not in self.parameters or not (value == oldvalue):
if isinstance(oldvalue, dict):
# Special treatment for dictionary parameters:
for name in value:
if name not in oldvalue:
raise KeyError('Unknown subparameter "{}" in '
'dictionary parameter "{}"'.format(
name, key))
oldvalue.update(value)
value = oldvalue
changed_parameters[key] = value
self.parameters[key] = value
return changed_parameters
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_orca_input(self.label + '.inp')
self.read_results()
def __init__(self,
label='siesta',
mesh_cutoff=200 * Ry,
energy_shift=100 * meV,
kpts=(1, 1, 1),
xc='LDA',
basis_set='DZP',
spin='COLLINEAR',
species=tuple(),
pseudo_qualifier=None,
pseudo_path=None,
atoms=None,
restart=None,
ignore_bad_restart_file=False,
fdf_arguments=None):
kwargs = locals()
kwargs.pop('self')
Parameters.__init__(self, **kwargs)
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,
cutoff=Cosine(6.5),
Gs=None,
nmax=5,
dblabel=None,
elements=None,
version='2016.02',
mode='atom-centered',
fortran=True):
# Check of the version of descriptor, particularly if restarting.
compatibleversions = [
'2016.02',
]
if (version is not None) and version not in compatibleversions:
raise RuntimeError('Error: Trying to use Zernike fingerprints'
' version %s, but this module only supports'
' versions %s. You may need an older or '
' newer version of Amp.' %
(version, compatibleversions))
else:
version = compatibleversions[-1]
# Check that the mode is atom-centered.
if mode != 'atom-centered':
raise RuntimeError('Zernike scheme only works '
'in atom-centered mode. %s '
'specified.' % mode)
# If the cutoff is provided as a number, Cosine function will be used
# by default.
if isinstance(cutoff, int) or isinstance(cutoff, float):
cutoff = Cosine(cutoff)
# If the cutoff is provided as a dictionary, assume we need to load it
# with dict2cutoff.
if type(cutoff) is dict:
cutoff = dict2cutoff(cutoff)
# The parameters dictionary contains the minimum information
# to produce a compatible descriptor; that is, one that gives
# an identical fingerprint when fed an ASE image.
p = self.parameters = Parameters({
'importname': '.descriptor.zernike.Zernike',
'mode': 'atom-centered'
})
p.version = version
p.cutoff = cutoff.todict()
if p.cutoff['name'] == 'Polynomial':
self.gamma = cutoff.gamma
p.Gs = Gs
p.nmax = nmax
p.elements = elements
self.dblabel = dblabel
self.fortran = fortran
self.parent = None # Can hold a reference to main Amp instance.
def __init__(
self,
label='siesta',
mesh_cutoff=200 * Ry,
energy_shift=100 * meV,
kpts=(1, 1, 1),
xc='LDA',
basis_set='DZP',
spin='COLLINEAR',
species=tuple(),
pseudo_qualifier=None,
pseudo_path=None,
atoms=None,
restart=None,
ignore_bad_restart_file=False,
fdf_arguments=None):
kwargs = locals()
kwargs.pop('self')
Parameters.__init__(self, **kwargs)
def __init__(self, block):
"""
Parameters:
-block : String. A block defining the basis set of a single
specie using the format of a PAO.Basis block.
The initial label should be left out since it is
determined programatically.
Example1: 2 nodes 1.0
n=2 0 2 E 50.0 2.5
3.50 3.50
0.95 1.00
1 1 P 2
3.50
Example2: 1
0 2 S 0.2
5.00 0.00
See siesta manual for details.
"""
assert isinstance(block, str)
Parameters.__init__(self, block=block)
def __init__(self,
label='siesta',
mesh_cutoff=200 * Ry,
energy_shift=100 * meV,
kpts=None,
xc='LDA',
basis_set='DZP',
spin='non-polarized',
species=tuple(),
pseudo_qualifier=None,
pseudo_path=None,
symlink_pseudos=None,
atoms=None,
restart=None,
fdf_arguments=None,
atomic_coord_format='xyz',
bandpath=None):
kwargs = locals()
kwargs.pop('self')
Parameters.__init__(self, **kwargs)
def read(self, label):
"""Read results from ABINIT's text-output file."""
FileIOCalculator.read(self, label)
filename = self.label + '.txt'
if not os.path.isfile(filename):
raise ReadError
self.atoms = read_abinit(self.label + '.in')
self.parameters = Parameters.read(self.label + '.ase')
self.initialize(self.atoms)
self.read_results()
def __init__(self,
hiddenlayers=(5, 5),
activation='tanh',
weights=None,
scalings=None,
fprange=None,
regressor=None,
mode=None,
lossfunction=None,
version=None,
fortran=True,
checkpoints=100):
# Version check, particularly if restarting.
compatibleversions = [
'2015.12',
]
if (version is not None) and version not in compatibleversions:
raise RuntimeError('Error: Trying to use NeuralNetwork'
' version %s, but this module only supports'
' versions %s. You may need an older or '
'newer version of Amp.' %
(version, compatibleversions))
else:
version = compatibleversions[-1]
# The parameters dictionary contains the minimum information
# to produce a compatible model; e.g., one that gives
# the identical energy (and/or forces) when fed a fingerprint.
p = self.parameters = Parameters()
p.importname = '.model.neuralnetwork.NeuralNetwork'
p.version = version
p.hiddenlayers = hiddenlayers
p.weights = weights
p.scalings = scalings
p.fprange = fprange
p.activation = activation
p.mode = mode
# Checking that the activation function is given correctly:
if activation not in ['linear', 'tanh', 'sigmoid']:
_ = ('Unknown activation function %s; must be one of '
'"linear", "tanh", or "sigmoid".' % activation)
raise NotImplementedError(_)
self.regressor = regressor
self.parent = None # Can hold a reference to main Amp instance.
self.lossfunction = lossfunction
self.fortran = fortran
self.checkpoints = checkpoints
if self.lossfunction is None:
self.lossfunction = LossFunction()
def read_input(self, label):
""" Read MyMD input and restart file
Initializes self.frames with frame from restart file
and self.parameters with data form input file.
WARNING: This function is not yet properly implemented
"""
# TODO: make it take an arbitrary input filename
self.label = label
# If the input was generated by ASE, it is simple
if False and os.path.isfile(self.label + '.ase'):
self.parameters = Parameters.read(self.label + '.ase')
else:
if not os.path.isfile(self.label + '.inp'):
raise ReadError
f = open(self.label + '.inp')
s = f.readlines()
parse = self.parse_line
p = self.parameters
natoms = int(parse(s[0]))
# mass = float( parse(s[1]) ) #not needed, default in
# read_restart
epsilon = float(parse(s[2]))
sigma = float(parse(s[3]))
rcut = float(parse(s[4]))
box = parse(s[5])
restfile = parse(s[6])
trajfile = parse(s[7])
enerfile = parse(s[8])
nsteps = int(parse(s[9]))
dt = float(parse(s[10]))
nprint = int(parse(s[11]))
# TODO: start parsing the format...
atoms = io.read_restart(label + '.rest')
atoms.set_cell([box, box, box])
if len(atoms) != natoms:
s = "natoms = {} from {} does not match with\n".\
format(natoms, self.label + '.inp')
s = "natoms = {} from restart file {}".\
format(len(atoms), self.label + '.rest')
raise RuntimeError(s)
self.potentials = potentials.LJPotential(
epsilon=epsilon,
sigma=sigma,
rcut=rcut)
def __init__(
self,
cutoff=Cosine(6.5),
Gs=None,
dblabel=None,
elements=None,
version=None,
fortran=True,
mode="atom-centered",
):
# Check of the version of descriptor, particularly if restarting.
compatibleversions = ["2015.12"]
if (version is not None) and version not in compatibleversions:
raise RuntimeError("Error: Trying to use Gaussian fingerprints"
" version %s, but this module only supports"
" versions %s. You may need an older or "
" newer version of Amp." %
(version, compatibleversions))
else:
version = compatibleversions[-1]
# Check that the mode is atom-centered.
if mode != "atom-centered":
raise RuntimeError("Gaussian scheme only works "
"in atom-centered mode. %s "
"specified." % mode)
# If the cutoff is provided as a number, Cosine function will be used
# by default.
if isinstance(cutoff, int) or isinstance(cutoff, float):
cutoff = Cosine(cutoff)
# If the cutoff is provided as a dictionary, assume we need to load it
# with dict2cutoff.
if type(cutoff) is dict:
cutoff = dict2cutoff(cutoff)
# The parameters dictionary contains the minimum information
# to produce a compatible descriptor; that is, one that gives
# an identical fingerprint when fed an ASE image.
p = self.parameters = Parameters({
"importname": ".descriptor.gaussian.Gaussian",
"mode": "atom-centered"
})
p.version = version
p.cutoff = cutoff.todict()
p.Gs = Gs
p.elements = elements
self.dblabel = dblabel
self.fortran = fortran
self.parent = None # Can hold a reference to main Amp instance.
def read(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 = read_aims(geometry)
self.parameters = Parameters.read(os.path.join(self.directory,
'parameters.ase'))
self.read_results()
def read(self, label):
FileIOCalculator.read(self, label)
geometry = self.label + '.car'
output = self.label + '.outmol'
force = self.label + '.grad'
for filename in [force, output, geometry]:
if not os.path.isfile(filename):
raise ReadError
self.atoms = read(geometry)
self.parameters = Parameters.read(self.label + 'parameters.ase')
self.read_results()
def read(self, label):
super().read(label)
with open(label + ".json", "r") as fp:
saved_dict = json.load(fp)
self.parameters = Parameters(saved_dict["parameters"])
self.scfres = saved_dict.get("scfres", None)
self.results = saved_dict["results"]
# Some results need to be numpy arrays:
for key in ("forces", ):
self.results[key] = np.array(self.results[key])
with io.StringIO(saved_dict["atoms"]) as fp:
self.atoms = ase.io.read(fp, format="json")
def save(self, filename, overwrite=False):
"""Saves the calculator in way that it can be re-opened with
load."""
if os.path.exists(filename):
if overwrite is False:
oldfilename = filename
filename = tempfile.NamedTemporaryFile(mode='w', delete=False,
suffix='.amp').name
self.log('File "%s" exists. Instead saving to "%s".' %
(oldfilename, filename))
else:
oldfilename = tempfile.NamedTemporaryFile(mode='w',
delete=False,
suffix='.amp').name
self.log('Overwriting file: "%s". Moving original to "%s".'
% (filename, oldfilename))
shutil.move(filename, oldfilename)
descriptor = self.descriptor.tostring()
model = self.model.tostring()
p = Parameters({'descriptor': descriptor,
'model': model})
p.write(filename)
return filename
def read(self, label):
"""Used to read the results of a previous calculation if restarting"""
FileIOCalculator.read(self, label)
from ase.io.gaussian import read_gaussian_out
filename = self.label + '.log'
if not os.path.isfile(filename):
raise ReadError
self.atoms = read_gaussian_out(filename, quantity='atoms')
self.parameters = Parameters.read(self.label + '.ase')
initial_magmoms = self.parameters.pop('initial_magmoms')
self.atoms.set_initial_magnetic_moments(initial_magmoms)
self.read_results()
def read(self, label):
FileIOCalculator.read(self, label)
totenergy = os.path.join(self.directory, 'TOTENERGY.OUT')
eigval = os.path.join(self.directory, 'EIGVAL.OUT')
kpoints = os.path.join(self.directory, 'KPOINTS.OUT')
for filename in [totenergy, eigval, kpoints, self.out]:
if not os.path.isfile(filename):
raise ReadError
# read state from elk.in because *.OUT do not provide enough digits!
self.atoms = read_elk(os.path.join(self.directory, 'elk.in'))
self.parameters = Parameters.read(os.path.join(self.directory,
'parameters.ase'))
self.initialize(self.atoms)
self.read_results()
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 __init__(self,
cutoff=Cosine(6.5),
anotherparameter=12.2,
dblabel=None,
elements=None,
version=None,
mode='atom-centered'):
# Check of the version of descriptor, particularly if restarting.
compatibleversions = [
'2016.02',
]
if (version is not None) and version not in compatibleversions:
raise RuntimeError('Error: Trying to use Example fingerprints'
' version %s, but this module only supports'
' versions %s. You may need an older or '
' newer version of Amp.' %
(version, compatibleversions))
else:
version = compatibleversions[-1]
# Check that the mode is atom-centered.
if mode != 'atom-centered':
raise RuntimeError('This scheme only works '
'in atom-centered mode. %s '
'specified.' % mode)
# If the cutoff is provided as a number, Cosine function will be used
# by default.
if isinstance(cutoff, int) or isinstance(cutoff, float):
cutoff = Cosine(cutoff)
# The parameters dictionary contains the minimum information
# to produce a compatible descriptor; that is, one that gives
# an identical fingerprint when fed an ASE image.
p = self.parameters = Parameters({
'importname': '.descriptor.example.AtomCenteredExample',
'mode': 'atom-centered'
})
p.version = version
p.cutoff = cutoff.Rc
p.cutofffn = cutoff.__class__.__name__
p.anotherparameter = anotherparameter
p.elements = elements
self.dblabel = dblabel
self.parent = None # Can hold a reference to main Amp instance.
def read(self, label):
FileIOCalculator.read(self, label)
if not os.path.isfile(self.label + '.out'):
raise ReadError
with open(self.label + '.out') as f:
lines = f.readlines()
self.parameters = Parameters(task='', method='')
p = self.parameters
parm_line = self.read_parameters_from_file(lines)
for keyword in parm_line.split():
if 'RELSCF' in keyword:
p.relscf = float(keyword.split('=')[-1])
elif keyword in self.methods:
p.method = keyword
else:
p.task += keyword + ' '
p.task.rstrip()
self.read_results()
def read(self, label):
FileIOCalculator.read(self, label)
if not os.path.isfile(self.label + ".out"):
raise ReadError
f = open(self.label + ".nw")
for line in f:
if line.startswith("geometry"):
break
symbols = []
positions = []
for line in f:
if line.startswith("end"):
break
words = line.split()
symbols.append(words[0])
positions.append([float(word) for word in words[1:]])
self.parameters = Parameters.read(self.label + ".ase")
self.state = Atoms(symbols, positions, magmoms=self.parameters.pop("magmoms"))
self.read_results()
def read(self, label):
FileIOCalculator.read(self, label)
if not os.path.isfile(self.label + '.out'):
raise ReadError
f = open(self.label + '.nw')
for line in f:
if line.startswith('geometry'):
break
symbols = []
positions = []
for line in f:
if line.startswith('end'):
break
words = line.split()
symbols.append(words[0])
positions.append([float(word) for word in words[1:]])
self.parameters = Parameters.read(self.label + '.ase')
self.atoms = Atoms(symbols, positions,
magmoms=self.parameters.pop('initial_magmoms'))
self.read_results()
def set(self, **kwargs):
"""Set all parameters.
Parameters:
kwargs : Dictionary containing the keywords for deMon
"""
# Put in the default arguments.
kwargs = self.default_parameters.__class__(**kwargs)
if 'parameters' in kwargs:
filename = kwargs.pop('parameters')
parameters = Parameters.read(filename)
parameters.update(kwargs)
kwargs = parameters
changed_parameters = {}
for key, value in kwargs.items():
oldvalue = self.parameters.get(key)
if key not in self.parameters or not equal(value, oldvalue):
changed_parameters[key] = value
self.parameters[key] = value
return changed_parameters
def read(self, label):
'Read atoms, parameters and calculated results from restart files.'
from numpy import array # needed by eval(<label_results.ase>)
self.atoms = ase.io.read(label + '_restart.traj')
self.parameters = Parameters.read(label + '_params.ase')
self.results = eval(open(label + '_results.ase').read())
def read(self, label):
'Read atoms, parameters and calculated results from restart files.'
self.atoms = ase.io.read(label + '_restart.traj')
self.parameters = Parameters.read(label + '_params.ase')
results_txt = open(label + '_results.ase').read()
self.results = eval(results_txt, {'array': np.array})
