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 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})