def set(self, **kwargs):
"""Set octopus input file parameters."""
kwargs = normalize_keywords(kwargs)
self.check_keywords_exist(kwargs)
for keyword in kwargs:
if keyword in self.troublesome_keywords:
msg = ('ASE-Octopus interface will probably misbehave with '
'the %s parameter. Optimists may use '
'Octopus(ignore_troublesome_keywords=[kw1, kw2, ...])'
'to override this.' % keyword)
raise OctopusKeywordError(msg)
FileIOCalculator.set(self, **kwargs)
self.kwargs.update(kwargs)
def set(self, **kwargs):
"""Set octopus input file parameters.
:param kwargs:
"""
kwargs = purify(kwargs)
for keyword in kwargs:
if keyword in self.troublesome_keywords:
msg = ('ASE-Octopus interface probably will misbehave with '
'the %s parameter. You may use '
'Octopus(ignore_troublesome_keywords=[kw1, kw2, ...])'
'to override this.' % keyword)
raise OctopusKeywordError(msg)
FileIOCalculator.set(self, **kwargs)
self.kwargs = kwargs
def set(self, **kwargs):
"""Set octopus input file parameters."""
kwargs = normalize_keywords(kwargs)
changes = FileIOCalculator.set(self, **kwargs)
if changes:
self.results.clear()
self.kwargs.update(kwargs)
def set(self, **kwargs):
"""
Sets the parameters on the according keywords
Raises RuntimeError when wrong keyword is provided
"""
changed_parameters = FileIOCalculator.set(self, **kwargs)
if changed_parameters:
self.reset()
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 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 set(self, **kwargs):
"""Set octopus input file parameters."""
kwargs = normalize_keywords(kwargs)
if self.octopus_keywords is not None:
self.check_keywords_exist(kwargs)
for keyword in kwargs:
if keyword in self.troublesome_keywords:
msg = ('ASE-Octopus interface will probably misbehave with '
'the %s parameter. Optimists may use '
'Octopus(ignore_troublesome_keywords=[kw1, kw2, ...])'
'to override this.' % keyword)
raise OctopusKeywordError(msg)
changes = FileIOCalculator.set(self, **kwargs)
if changes:
self.results.clear()
self.kwargs.update(kwargs)
def set(self, **kwargs):
"""Set parameters with keyword=value pairs.
calc.set(xc='PBE')
A few special kwargs are handled separately to expand them
prior to setting the parameters. This is done to enable one
set to track changes.
"""
log.debug('Setting {}'.format(kwargs))
if 'xc' in kwargs:
kwargs.update(self.set_xc_dict(kwargs['xc']))
if 'ispin' in kwargs:
kwargs.update(self.set_ispin_dict(kwargs['ispin']))
if 'ldau_luj' in kwargs:
kwargs.update(self.set_ldau_luj_dict(kwargs['ldau_luj']))
original_params = self.parameters
changed_parameters = FileIOCalculator.set(self, **kwargs)
# If we are implementing special setups, the ppp_list needs
# to be updated so the POSCAR and POTCAR can be written correctly.
if 'setups' in changed_parameters.keys():
self.sort_atoms(self.atoms)
# we don't consider None values to be changed if the keyword was
# not originally in the parameters.
# cp = {k: v for k, v in changed_parameters.iteritems() # Changed for Python 3 compatibility
cp = {
k: v
for k, v in changed_parameters.items()
if v is not None and k not in original_params
}
if cp != {}:
log.debug('resetting because {} changed.'.format(cp))
self.reset()
return changed_parameters
def set(self, **kwargs):
'''Update parameters self.parameter member variable.
1. Add default values for repeated parameter sections with self.default_parameters using order.
2. Also add empty dictionary as an indicator for section existence if no relevant default_parameters exist.
3. Update parameters from arguments.
Returns
=======
Updated parameter
'''
new_parameters = deepcopy(self.parameters)
changed_parameters = FileIOCalculator.set(self, **kwargs)
# Add default values for repeated parameter sections with self.default_parameters using order.
# Also add empty dictionary as an indicator for section existence if no relevant default_parameters exist.
if 'order' in kwargs:
new_parameters['order'] = kwargs['order']
section_sets = set(kwargs['order'])
for section_name in section_sets:
repeat = kwargs['order'].count(section_name)
if section_name in self.default_parameters.keys():
for i in range(repeat - 1):
new_parameters[section_name] += deepcopy(
self.default_parameters[section_name])
else:
new_parameters[section_name] = []
for i in range(repeat):
new_parameters[section_name].append({})
# Update parameters
for section in new_parameters['order']:
if section in kwargs.keys():
if isinstance(kwargs[section], dict):
kwargs[section] = [kwargs[section]]
i = 0
for section_param in kwargs[section]:
new_parameters[section][i] = update_parameter(
new_parameters[section][i], section_param)
i += 1
self.parameters = new_parameters
return changed_parameters
def set(self, **kwargs):
"""Set parameters with keyword=value pairs.
calc.set(xc='PBE')
A few special kwargs are handled separately to expand them
prior to setting the parameters. This is done to enable one
set to track changes.
"""
log.debug('Setting {}'.format(kwargs))
if 'xc' in kwargs:
kwargs.update(self.set_xc_dict(kwargs['xc']))
if 'ispin' in kwargs:
kwargs.update(self.set_ispin_dict(kwargs['ispin']))
if 'ldau_luj' in kwargs:
kwargs.update(self.set_ldau_luj_dict(kwargs['ldau_luj']))
if 'nsw' in kwargs:
kwargs.update(self.set_nsw_dict(kwargs['nsw']))
original_params = self.parameters
changed_parameters = FileIOCalculator.set(self, **kwargs)
# we don't consider None values to be changed if the keyword was
# not originally in the parameters.
cp = {
k: v
for k, v in changed_parameters.iteritems()
if v is not None and k not in original_params
}
if cp != {}:
log.debug('resetting because {} changed.'.format(cp))
self.reset()
return changed_parameters
def set(self, **kwargs):
"""Override the set function, to test for changes in the
Vasp FileIO Calculator, then call the create_input.set()
on remaining inputs for VASP specific keys.
Allows for setting ``label``, ``directory`` and ``txt``
without resetting the results in the calculator.
"""
changed_parameters = {}
if 'label' in kwargs:
label = kwargs.pop('label')
self.set_label(label)
if 'directory' in kwargs:
# If we explicitly set directory, overwrite the one in label.
# XXX: Should we just raise an error here if clash?
directory = kwargs.pop('directory')
label = os.path.join(directory, self.prefix)
self.set_label(label)
if 'txt' in kwargs:
txt = kwargs.pop('txt')
self.set_txt(txt)
if 'atoms' in kwargs:
atoms = kwargs.pop('atoms')
self.set_atoms(atoms) # Resets results
changed_parameters.update(FileIOCalculator.set(self, **kwargs))
# We might at some point add more to changed parameters, or use it
if changed_parameters:
self.results.clear() # We don't want to clear atoms
if kwargs:
# If we make any changes to Vasp input, we always reset
GenerateVaspInput.set(self, **kwargs)
self.results.clear()
def set(self, **kwargs):
"""Set parameters with keyword=value pairs.
calc.set(xc='PBE')
A few special kwargs are handled separately to expand them
prior to setting the parameters. This is done to enable one
set to track changes.
"""
log.debug('Setting {}'.format(kwargs))
if 'xc' in kwargs:
kwargs.update(self.set_xc_dict(kwargs['xc']))
if 'ispin' in kwargs:
kwargs.update(self.set_ispin_dict(kwargs['ispin']))
if 'ldau_luj' in kwargs:
kwargs.update(self.set_ldau_luj_dict(kwargs['ldau_luj']))
original_params = self.parameters
changed_parameters = FileIOCalculator.set(self, **kwargs)
# If we are implementing special setups, the ppp_list needs
# to be updated so the POSCAR and POTCAR can be written correctly.
if 'setups' in changed_parameters.keys():
self.sort_atoms(self.atoms)
# we don't consider None values to be changed if the keyword was
# not originally in the parameters.
cp = {k: v for k, v in changed_parameters.iteritems()
if v is not None and k not in original_params}
if cp != {}:
log.debug('resetting because {} changed.'.format(cp))
self.reset()
return changed_parameters
def set(self, **kwargs):
"""Set parameters with keyword=value pairs.
calc.set(xc='PBE')
A few special kwargs are handled separately to expand them
prior to setting the parameters. This is done to enable one
set to track changes.
"""
log.debug('Setting {}'.format(kwargs))
if 'xc' in kwargs:
kwargs.update(self.set_xc_dict(kwargs['xc']))
if 'ispin' in kwargs:
kwargs.update(self.set_ispin_dict(kwargs['ispin']))
if 'ldau_luj' in kwargs:
kwargs.update(self.set_ldau_luj_dict(kwargs['ldau_luj']))
if 'nsw' in kwargs:
kwargs.update(self.set_nsw_dict(kwargs['nsw']))
original_params = self.parameters
changed_parameters = FileIOCalculator.set(self, **kwargs)
# we don't consider None values to be changed if the keyword was
# not originally in the parameters.
cp = {k: v for k, v in changed_parameters.iteritems()
if v is not None and k not in original_params}
if cp != {}:
log.debug('resetting because {} changed.'.format(cp))
self.reset()
return changed_parameters
def set(self, **kwargs):
changed_parameters = FileIOCalculator.set(self, **kwargs)
if changed_parameters:
self.reset()
def set(self, **kwargs):
# from the standard ase.calculators
changed_parameters = FileIOCalculator.set(self, **kwargs)
if changed_parameters:
self.reset()
def set(self, **kwargs):
changed_parameters = {}
# Convert from 'func' keyword to 'xc'. Internally, we only store
# 'xc', but 'func' is also allowed since it is consistent with the
# CLI dftd3 interface.
if kwargs.get('func'):
if kwargs.get('xc') and kwargs['func'] != kwargs['xc']:
raise RuntimeError('Both "func" and "xc" were provided! '
'Please provide at most one of these '
'two keywords. The preferred keyword '
'is "xc"; "func" is allowed for '
'consistency with the CLI dftd3 '
'interface.')
if kwargs['func'] != self.parameters['xc']:
changed_parameters['xc'] = kwargs['func']
self.parameters['xc'] = kwargs['func']
# dftd3 only implements energy, forces, and stresses (for periodic
# systems). But, if a DFT calculator is attached, and that calculator
# implements more properties, we will expose those properties too.
if 'dft' in kwargs:
dft = kwargs.pop('dft')
if dft is not self.dft:
changed_parameters['dft'] = dft
if dft is None:
self.implemented_properties = self.dftd3_implemented_properties
else:
self.implemented_properties = dft.implemented_properties
self.dft = dft
# If the user did not supply an XC functional, but did attach a
# DFT calculator that has XC set, then we will use that. Note that
# DFTD3's spelling convention is different from most, so in general
# you will have to explicitly set XC for both the DFT calculator and
# for DFTD3 (and DFTD3's will likely be spelled differently...)
if self.parameters['xc'] is None and self.dft is not None:
if self.dft.parameters.get('xc'):
self.parameters['xc'] = self.dft.parameters['xc']
# Check for unknown arguments. Don't raise an error, just let the
# user know that we don't understand what they're asking for.
unknown_kwargs = set(kwargs) - set(self.default_parameters)
if unknown_kwargs:
warn('WARNING: Ignoring the following unknown keywords: {}'
''.format(', '.join(unknown_kwargs)))
changed_parameters.update(FileIOCalculator.set(self, **kwargs))
# Ensure damping method is valid (zero, bj, zerom, bjm).
if self.parameters['damping'] is not None:
self.parameters['damping'] = self.parameters['damping'].lower()
if self.parameters['damping'] not in self.damping_methods:
raise ValueError('Unknown damping method {}!'
''.format(self.parameters['damping']))
# d2 only is valid with 'zero' damping
elif self.parameters['old'] and self.parameters['damping'] != 'zero':
raise ValueError('Only zero-damping can be used with the D2 '
'dispersion correction method!')
# If cnthr (cutoff for three-body and CN calculations) is greater
# than cutoff (cutoff for two-body calculations), then set the former
# equal to the latter, since that doesn't make any sense.
if self.parameters['cnthr'] > self.parameters['cutoff']:
warn('WARNING: CN cutoff value of {cnthr} is larger than '
'regular cutoff value of {cutoff}! Reducing CN cutoff '
'to {cutoff}.'
''.format(cnthr=self.parameters['cnthr'],
cutoff=self.parameters['cutoff']))
self.parameters['cnthr'] = self.parameters['cutoff']
# If you only care about the energy, gradient calculations (forces,
# stresses) can be bypassed. This will greatly speed up calculations
# in dense 3D-periodic systems with three-body corrections. But, we
# can no longer say that we implement forces and stresses.
if not self.parameters['grad']:
for val in ['forces', 'stress']:
if val in self.implemented_properties:
self.implemented_properties.remove(val)
# Check to see if we're using custom damping parameters.
zero_damppars = {'s6', 'sr6', 's8', 'sr8', 'alpha6'}
bj_damppars = {'s6', 'a1', 's8', 'a2', 'alpha6'}
zerom_damppars = {'s6', 'sr6', 's8', 'beta', 'alpha6'}
all_damppars = zero_damppars | bj_damppars | zerom_damppars
self.custom_damp = False
damping = self.parameters['damping']
damppars = set(kwargs) & all_damppars
if damppars:
self.custom_damp = True
if damping == 'zero':
valid_damppars = zero_damppars
elif damping in ['bj', 'bjm']:
valid_damppars = bj_damppars
elif damping == 'zerom':
valid_damppars = zerom_damppars
# If some but not all damping parameters are provided for the
# selected damping method, raise an error. We don't have "default"
# values for damping parameters, since those are stored in the
# dftd3 executable & depend on XC functional.
missing_damppars = valid_damppars - damppars
if missing_damppars and missing_damppars != valid_damppars:
raise ValueError('An incomplete set of custom damping '
'parameters for the {} damping method was '
'provided! Expected: {}; got: {}'
''.format(damping,
', '.join(valid_damppars),
', '.join(damppars)))
# If a user provides damping parameters that are not used in the
# selected damping method, let them know that we're ignoring them.
# If the user accidentally provided the *wrong* set of parameters,
# (e.g., the BJ parameters when they are using zero damping), then
# the previous check will raise an error, so we don't need to
# worry about that here.
if damppars - valid_damppars:
warn('WARNING: The following damping parameters are not '
'valid for the {} damping method and will be ignored: {}'
''.format(damping,
', '.join(damppars)))
# The default XC functional is PBE, but this is only set if the user
# did not provide their own value for xc or any custom damping
# parameters.
if self.parameters['xc'] and self.custom_damp:
warn('WARNING: Custom damping parameters will be used '
'instead of those parameterized for {}!'
''.format(self.parameters['xc']))
if changed_parameters:
self.results.clear()
return changed_parameters
def set_fdf_arguments(self, fdf_arguments):
""" Set the fdf_arguments after the initialization of the
calculator.
"""
self.validate_fdf_arguments(fdf_arguments)
FileIOCalculator.set(self, fdf_arguments=fdf_arguments)
def set(self, **kwargs):
"""Set all parameters.
Parameters:
-kwargs : Dictionary containing the keywords defined in
SiestaParameters.
"""
# XXX Inserted these next few lines because set() would otherwise
# discard all previously set keywords to their defaults! --askhl
current = self.parameters.copy()
current.update(kwargs)
kwargs = current
# Find not allowed keys.
default_keys = list(self.__class__.default_parameters)
offending_keys = set(kwargs) - set(default_keys)
if len(offending_keys) > 0:
mess = "'set' does not take the keywords: %s "
raise ValueError(mess % list(offending_keys))
# Use the default parameters.
parameters = self.__class__.default_parameters.copy()
parameters.update(kwargs)
kwargs = parameters
# Check energy inputs.
for arg in ['mesh_cutoff', 'energy_shift']:
value = kwargs.get(arg)
if value is None:
continue
if not (isinstance(value, (float, int)) and value > 0):
mess = "'%s' must be a positive number(in eV), \
got '%s'" % (arg, value)
raise ValueError(mess)
# Check the basis set input.
if 'basis_set' in kwargs:
basis_set = kwargs['basis_set']
allowed = self.allowed_basis_names
if not (isinstance(basis_set, PAOBasisBlock) or
basis_set in allowed):
mess = "Basis must be either %s, got %s" % (allowed, basis_set)
raise ValueError(mess)
# Check the spin input.
if 'spin' in kwargs:
if kwargs['spin'] == 'UNPOLARIZED':
warnings.warn("The keyword 'UNPOLARIZED' is deprecated,"
"and replaced by 'non-polarized'",
np.VisibleDeprecationWarning)
kwargs['spin'] = 'non-polarized'
spin = kwargs['spin']
if spin is not None and (spin.lower() not in self.allowed_spins):
mess = "Spin must be %s, got '%s'" % (self.allowed_spins, spin)
raise ValueError(mess)
# Check the functional input.
xc = kwargs.get('xc', 'LDA')
if isinstance(xc, (tuple, list)) and len(xc) == 2:
functional, authors = xc
if functional.lower() not in [k.lower() for k in self.allowed_xc]:
mess = "Unrecognized functional keyword: '%s'" % functional
raise ValueError(mess)
lsauthorslower = [a.lower() for a in self.allowed_xc[functional]]
if authors.lower() not in lsauthorslower:
mess = "Unrecognized authors keyword for %s: '%s'"
raise ValueError(mess % (functional, authors))
elif xc in self.allowed_xc:
functional = xc
authors = self.allowed_xc[xc][0]
else:
found = False
for key, value in self.allowed_xc.items():
if xc in value:
found = True
functional = key
authors = xc
break
if not found:
raise ValueError("Unrecognized 'xc' keyword: '%s'" % xc)
kwargs['xc'] = (functional, authors)
# Check fdf_arguments.
if kwargs['fdf_arguments'] is None:
kwargs['fdf_arguments'] = {}
if not isinstance(kwargs['fdf_arguments'], dict):
raise TypeError("fdf_arguments must be a dictionary.")
# Call baseclass.
FileIOCalculator.set(self, **kwargs)
def set(self, **kwargs):
changed_parameters = {}
# Convert from 'func' keyword to 'xc'. Internally, we only store
# 'xc', but 'func' is also allowed since it is consistent with the
# CLI dftd3 interface.
if kwargs.get('func'):
if kwargs.get('xc') and kwargs['func'] != kwargs['xc']:
raise RuntimeError('Both "func" and "xc" were provided! '
'Please provide at most one of these '
'two keywords. The preferred keyword '
'is "xc"; "func" is allowed for '
'consistency with the CLI dftd3 '
'interface.')
if kwargs['func'] != self.parameters['xc']:
changed_parameters['xc'] = kwargs['func']
self.parameters['xc'] = kwargs['func']
# dftd3 only implements energy, forces, and stresses (for periodic
# systems). But, if a DFT calculator is attached, and that calculator
# implements more properties, we will expose those properties too.
if 'dft' in kwargs:
dft = kwargs.pop('dft')
if dft is not self.dft:
changed_parameters['dft'] = dft
if dft is None:
self.implemented_properties = self.dftd3_implemented_properties
else:
self.implemented_properties = dft.implemented_properties
self.dft = dft
# If the user did not supply an XC functional, but did attach a
# DFT calculator that has XC set, then we will use that. Note that
# DFTD3's spelling convention is different from most, so in general
# you will have to explicitly set XC for both the DFT calculator and
# for DFTD3 (and DFTD3's will likely be spelled differently...)
if self.parameters['xc'] is None and self.dft is not None:
if self.dft.parameters.get('xc'):
self.parameters['xc'] = self.dft.parameters['xc']
# Check for unknown arguments. Don't raise an error, just let the
# user know that we don't understand what they're asking for.
unknown_kwargs = set(kwargs) - set(self.default_parameters)
if unknown_kwargs:
warn('WARNING: Ignoring the following unknown keywords: {}'
''.format(', '.join(unknown_kwargs)))
changed_parameters.update(FileIOCalculator.set(self, **kwargs))
# Ensure damping method is valid (zero, bj, zerom, bjm).
if self.parameters['damping'] is not None:
self.parameters['damping'] = self.parameters['damping'].lower()
if self.parameters['damping'] not in self.damping_methods:
raise ValueError('Unknown damping method {}!'
''.format(self.parameters['damping']))
# d2 only is valid with 'zero' damping
elif self.parameters['old'] and self.parameters['damping'] != 'zero':
raise ValueError('Only zero-damping can be used with the D2 '
'dispersion correction method!')
# If cnthr (cutoff for three-body and CN calculations) is greater
# than cutoff (cutoff for two-body calculations), then set the former
# equal to the latter, since that doesn't make any sense.
if self.parameters['cnthr'] > self.parameters['cutoff']:
warn('WARNING: CN cutoff value of {cnthr} is larger than '
'regular cutoff value of {cutoff}! Reducing CN cutoff '
'to {cutoff}.'
''.format(cnthr=self.parameters['cnthr'],
cutoff=self.parameters['cutoff']))
self.parameters['cnthr'] = self.parameters['cutoff']
# If you only care about the energy, gradient calculations (forces,
# stresses) can be bypassed. This will greatly speed up calculations
# in dense 3D-periodic systems with three-body corrections. But, we
# can no longer say that we implement forces and stresses.
if not self.parameters['grad']:
for val in ['forces', 'stress']:
if val in self.implemented_properties:
self.implemented_properties.remove(val)
# Check to see if we're using custom damping parameters.
zero_damppars = {'s6', 'sr6', 's8', 'sr8', 'alpha6'}
bj_damppars = {'s6', 'a1', 's8', 'a2', 'alpha6'}
zerom_damppars = {'s6', 'sr6', 's8', 'beta', 'alpha6'}
all_damppars = zero_damppars | bj_damppars | zerom_damppars
self.custom_damp = False
damping = self.parameters['damping']
damppars = set(kwargs) & all_damppars
if damppars:
self.custom_damp = True
if damping == 'zero':
valid_damppars = zero_damppars
elif damping in ['bj', 'bjm']:
valid_damppars = bj_damppars
elif damping == 'zerom':
valid_damppars = zerom_damppars
# If some but not all damping parameters are provided for the
# selected damping method, raise an error. We don't have "default"
# values for damping parameters, since those are stored in the
# dftd3 executable & depend on XC functional.
missing_damppars = valid_damppars - damppars
if missing_damppars and missing_damppars != valid_damppars:
raise ValueError('An incomplete set of custom damping '
'parameters for the {} damping method was '
'provided! Expected: {}; got: {}'
''.format(damping, ', '.join(valid_damppars),
', '.join(damppars)))
# If a user provides damping parameters that are not used in the
# selected damping method, let them know that we're ignoring them.
# If the user accidentally provided the *wrong* set of parameters,
# (e.g., the BJ parameters when they are using zero damping), then
# the previous check will raise an error, so we don't need to
# worry about that here.
if damppars - valid_damppars:
warn('WARNING: The following damping parameters are not '
'valid for the {} damping method and will be ignored: {}'
''.format(damping, ', '.join(damppars)))
# The default XC functional is PBE, but this is only set if the user
# did not provide their own value for xc or any custom damping
# parameters.
if self.parameters['xc'] and self.custom_damp:
warn('WARNING: Custom damping parameters will be used '
'instead of those parameterized for {}!'
''.format(self.parameters['xc']))
if changed_parameters:
self.results.clear()
return changed_parameters
def set(self, **kwargs):
"""Set all parameters.
Parameters:
-kwargs : Dictionary containing the keywords defined in
SiestaParameters.
"""
# Find not allowed keys.
default_keys = list(self.__class__.default_parameters)
offending_keys = set(kwargs) - set(default_keys)
if len(offending_keys) > 0:
mess = "'set' does not take the keywords: %s "
raise ValueError(mess % list(offending_keys))
# Check energy inputs.
for arg in ['mesh_cutoff', 'energy_shift']:
value = kwargs.get(arg)
if value is None:
continue
if not (isinstance(value, (float, int)) and value > 0):
mess = "'%s' must be a positive number(in eV), \
got '%s'" % (arg, value)
raise ValueError(mess)
# Check the basis set input.
if 'basis_set' in kwargs:
basis_set = kwargs['basis_set']
allowed = self.allowed_basis_names
if not (isinstance(basis_set, PAOBasisBlock)
or basis_set in allowed):
mess = "Basis must be either %s, got %s" % (allowed, basis_set)
raise ValueError(mess)
# Check the spin input.
if 'spin' in kwargs:
spin = kwargs['spin']
if spin is not None and (spin not in self.allowed_spins):
mess = "Spin must be %s, got %s" % (self.allowed_spins, spin)
raise ValueError(mess)
# Check the functional input.
xc = kwargs.get('xc')
if isinstance(xc, (tuple, list)) and len(xc) == 2:
functional, authors = xc
if functional not in self.allowed_xc:
mess = "Unrecognized functional keyword: '%s'" % functional
raise ValueError(mess)
if authors not in self.allowed_xc[functional]:
mess = "Unrecognized authors keyword for %s: '%s'"
raise ValueError(mess % (functional, authors))
elif xc in self.allowed_xc:
functional = xc
authors = self.allowed_xc[xc][0]
else:
found = False
for key, value in self.allowed_xc.items():
if xc in value:
found = True
functional = key
authors = xc
break
if not found:
raise ValueError("Unrecognized 'xc' keyword: '%s'" % xc)
kwargs['xc'] = (functional, authors)
# Check fdf_arguments.
fdf_arguments = kwargs.get('fdf_arguments')
self.validate_fdf_arguments(fdf_arguments)
FileIOCalculator.set(self, **kwargs)
def set(self, **kwargs):
"""Set all parameters.
Parameters:
-kwargs : Dictionary containing the keywords defined in
SiestaParameters.
"""
# Put in the default arguments.
kwargs = self.default_parameters.__class__(**kwargs)
# Check energy inputs.
for arg in ['mesh_cutoff', 'energy_shift']:
value = kwargs.get(arg)
if not (isinstance(value, (float, int)) and value > 0):
mess = "'%s' must be a positive number(in eV), \
got '%s'" % (arg, value)
raise ValueError(mess)
# Check the basis set input.
basis_set = kwargs.get('basis_set')
allowed = self.allowed_basis_names
if not (isinstance(basis_set, PAOBasisBlock) or basis_set in allowed):
mess = "Basis must be either %s, got %s" % (allowed, basis_set)
raise Exception(mess)
# Check the spin input.
spin = kwargs.get('spin')
if spin is not None and (spin not in self.allowed_spins):
mess = "Spin must be %s, got %s" % (self.allowed_spins, spin)
raise Exception(mess)
# Check the functional input.
xc = kwargs.get('xc')
if isinstance(xc, (tuple, list)) and len(xc) == 2:
functional, authors = xc
if not functional in self.allowed_xc:
mess = "Unrecognized functional keyword: '%s'" % functional
raise ValueError(mess)
if not authors in self.allowed_xc[functional]:
mess = "Unrecognized authors keyword for %s: '%s'"
raise ValueError(mess % (functional, authors))
elif xc in self.allowed_xc:
functional = xc
authors = self.allowed_xc[xc][0]
else:
found = False
for key, value in self.allowed_xc.iteritems():
if xc in value:
found = True
functional = key
authors = xc
break
if not found:
raise ValueError("Unrecognized 'xc' keyword: '%s'" % xc)
kwargs['xc'] = (functional, authors)
# Check fdf_arguments.
fdf_arguments = kwargs['fdf_arguments']
if fdf_arguments is not None:
# Type checking.
if not isinstance(fdf_arguments, dict):
raise TypeError("fdf_arguments must be a dictionary.")
# Check if keywords are allowed.
fdf_keys = set(fdf_arguments.keys())
allowed_keys = set(self.allowed_fdf_keywords)
if not fdf_keys.issubset(allowed_keys):
offending_keys = fdf_keys.difference(allowed_keys)
raise ValueError("The 'fdf_arguments' dictionary " +
"argument does not allow " +
"the keywords: %s" % str(offending_keys))
FileIOCalculator.set(self, **kwargs)
def set(self, **kwargs):
changed_parameters = FileIOCalculator.set(self, **kwargs)
if changed_parameters:
self.reset()
def set_fdf_arguments(self, fdf_arguments):
""" Set the fdf_arguments after the initialization of the
calculator.
"""
self.validate_fdf_arguments(fdf_arguments)
FileIOCalculator.set(self, fdf_arguments=fdf_arguments)
def set(self, **kwargs):
"""Set all parameters.
Parameters:
-kwargs : Dictionary containing the keywords defined in
SiestaParameters.
"""
# Find not allowed keys.
default_keys = self.__class__.default_parameters.keys()
offending_keys = set(kwargs) - set(default_keys)
if len(offending_keys) > 0:
mess = "'set' does not take the keywords: %s "
raise ValueError(mess % list(offending_keys))
# Check energy inputs.
for arg in ['mesh_cutoff', 'energy_shift']:
value = kwargs.get(arg)
if value is None:
continue
if not (isinstance(value, (float, int)) and value > 0):
mess = "'%s' must be a positive number(in eV), \
got '%s'" % (arg, value)
raise ValueError(mess)
# Check the basis set input.
if 'basis_set' in kwargs.keys():
basis_set = kwargs['basis_set']
allowed = self.allowed_basis_names
if not (isinstance(basis_set, PAOBasisBlock) or
basis_set in allowed):
mess = "Basis must be either %s, got %s" % (allowed, basis_set)
raise Exception(mess)
# Check the spin input.
if 'spin' in kwargs.keys():
spin = kwargs['spin']
if spin is not None and (spin not in self.allowed_spins):
mess = "Spin must be %s, got %s" % (self.allowed_spins, spin)
raise Exception(mess)
# Check the functional input.
xc = kwargs.get('xc')
if isinstance(xc, (tuple, list)) and len(xc) == 2:
functional, authors = xc
if functional not in self.allowed_xc:
mess = "Unrecognized functional keyword: '%s'" % functional
raise ValueError(mess)
if authors not in self.allowed_xc[functional]:
mess = "Unrecognized authors keyword for %s: '%s'"
raise ValueError(mess % (functional, authors))
elif xc in self.allowed_xc:
functional = xc
authors = self.allowed_xc[xc][0]
else:
found = False
for key, value in self.allowed_xc.iteritems():
if xc in value:
found = True
functional = key
authors = xc
break
if not found:
raise ValueError("Unrecognized 'xc' keyword: '%s'" % xc)
kwargs['xc'] = (functional, authors)
# Check fdf_arguments.
fdf_arguments = kwargs.get('fdf_arguments')
self.validate_fdf_arguments(fdf_arguments)
FileIOCalculator.set(self, **kwargs)
