def Minimisation_Function(cluster, collection, cluster_name):
#######################################################################################
cluster.pbc = True # make sure that the periodic boundry conditions are set off
#######################################################################################
# Perform the local optimisation method on the cluster.
original_path = os.getcwd()
offspring_name = str(cluster_name)
clusters_to_make_name = 'clusters_for_VASP'
if not os.path.exists(clusters_to_make_name):
os.makedir(clusters_to_make_name)
copyfile('VASP_Files/INCAR',
clusters_to_make_name + '/' + offspring_name + '/INCAR')
copyfile('VASP_Files/POTCAR',
clusters_to_make_name + '/' + offspring_name + '/POTCAR')
copyfile('VASP_Files/KPOINTS',
clusters_to_make_name + '/' + offspring_name + '/KPOINTS')
os.chdir(clusters_to_make_name + '/' + offspring_name)
ase_write(cluster, 'POSCAR', 'vasp')
startTime = time.time()
try:
Popen(['srun', 'vasp'])
except Exception:
pass
endTime = time.time()
cluster = ase_read('OUTCAR')
os.chdir(original_path)
####################################################################################################################
# Write information about the algorithm
Info = {}
Info["INFO.txt"] = ''
#Info["INFO.txt"] += ("No of Force Calls: " + str(dyn.get_number_of_steps()) + '\n')
Info["INFO.txt"] += ("Time (s): " + str(endTime - startTime) + '\n')
#Info["INFO.txt"] += ("Cluster converged?: " + str(dyn.converged()) + '\n')
####################################################################################################################
return cluster, converged, Info
def draw_3d(xyz=None, species=None, project_directory=None, save_only=False):
"""
Draws the molecule in a "3D-balls" style
If xyz ig given, it will be used, otherwise the function looks for species.final_xyz
Input coordinates are in string format
Saves an image if a species and `project_directory` are provided
If `save_only` is ``True``, then don't plot, only save the image
"""
xyz = check_xyz_species_for_drawing(xyz, species)
_, atoms, x, y, z = get_xyz_matrix(xyz)
atoms = [str(a) for a in atoms]
ase_atoms = list()
for i, atom in enumerate(atoms):
ase_atoms.append(Atom(symbol=atom, position=(x[i], y[i], z[i])))
ase_mol = Atoms(ase_atoms)
if not save_only:
display(view(ase_mol, viewer='x3d'))
if project_directory is not None and species is not None:
folder_name = 'rxns' if species.is_ts else 'Species'
geo_path = os.path.join(project_directory, 'output', folder_name,
species.label, 'geometry')
if not os.path.exists(geo_path):
os.makedirs(geo_path)
ase_write(filename=os.path.join(geo_path, 'geometry.png'),
images=ase_mol,
scale=100)
def write_traj(self,
filename,
format=None,
parallel=True,
append=False,
stride=1,
center_of_mass=False,
**kwargs):
"""
Writes the trajectory in a given file format based on the `ase.io.write`_ function.
Args:
filename (str): Filename of the output
format (str): The specific format of the output
parallel (bool):
append (bool):
stride (int): Writes trajectory every `stride` steps
center_of_mass (bool): True if the positions are centered on the COM
**kwargs: Additional ase arguments
.. _ase.io.write: https://wiki.fysik.dtu.dk/ase/_modules/ase/io/formats.html#write
"""
traj = self.trajectory(stride=stride, center_of_mass=center_of_mass)
# Using thr ASE output writer
ase_write(filename=filename,
images=traj,
format=format,
parallel=parallel,
append=append,
**kwargs)
def write(self, filename: str) -> None:
"""
Saves cluster space to a file.
Parameters
---------
filename
name of file to which to write
"""
with tarfile.open(name=filename, mode='w') as tar_file:
# write items
items = dict(cutoffs=self._cutoffs,
chemical_symbols=self._input_chemical_symbols,
pruning_history=self._pruning_history,
symprec=self.symprec,
position_tolerance=self.position_tolerance)
temp_file = tempfile.TemporaryFile()
pickle.dump(items, temp_file)
temp_file.seek(0)
tar_info = tar_file.gettarinfo(arcname='items', fileobj=temp_file)
tar_file.addfile(tar_info, temp_file)
temp_file.close()
# write structure
temp_file = tempfile.NamedTemporaryFile()
ase_write(temp_file.name, self._input_structure, format='json')
temp_file.seek(0)
tar_info = tar_file.gettarinfo(arcname='atoms', fileobj=temp_file)
tar_file.addfile(tar_info, temp_file)
temp_file.close()
def write(f_name, spg_molecule, pbc = None):
ase_primitive_cell = spglib_to_ase(spg_molecule)
if pbc:
assert(isinstance(pbc, tuple))
ase_primitive_cell.set_pbc(pbc)
ase_write(f_name, ase_primitive_cell)
return
def write_traj(
self,
filename,
file_format=None,
parallel=True,
append=False,
stride=1,
center_of_mass=False,
atom_indices=None,
snapshot_indices=None,
overwrite_positions=None,
overwrite_cells=None,
**kwargs
):
"""
Writes the trajectory in a given file file_format based on the `ase.io.write`_ function.
Args:
filename (str): Filename of the output
file_format (str): The specific file_format of the output
parallel (bool): ase parameter
append (bool): ase parameter
stride (int): Writes trajectory every `stride` steps
center_of_mass (bool): True if the positions are centered on the COM
atom_indices (list/numpy.ndarray): The atom indices for which the trajectory should be generated
snapshot_indices (list/numpy.ndarray): The snapshots for which the trajectory should be generated
overwrite_positions (list/numpy.ndarray): List of positions that are meant to overwrite the existing
trajectory. Useful to wrap coordinates for example
overwrite_cells(list/numpy.ndarray): List of cells that are meant to overwrite the existing
trajectory. Only used when `overwrite_positions` is defined. This must
have the same length of `overwrite_positions`
**kwargs: Additional ase arguments
.. _ase.io.write: https://wiki.fysik.dtu.dk/ase/_modules/ase/io/formats.html#write
"""
traj = self.trajectory(
stride=stride,
center_of_mass=center_of_mass,
atom_indices=atom_indices,
snapshot_indices=snapshot_indices,
overwrite_positions=overwrite_positions,
overwrite_cells=overwrite_cells
)
# Using thr ASE output writer
ase_write(
filename=filename,
images=traj,
format=file_format,
parallel=parallel,
append=append,
**kwargs
)
def calculate(self, structure, **kwargs):
atoms = scale_structure(
structure,
scaling_type=self.atoms_scaling,
atoms_scaling_cutoffs=self.atoms_scaling_cutoffs)
#Define descritpor
desc = descriptors.Descriptor(self.descriptor_options)
#Define structure as quippy Atoms object
filename = str(atoms.info['label']) + '.xyz'
ase_write(filename, atoms, format='xyz')
struct = quippy_Atoms(filename)
struct.set_pbc(self.p_b_c)
#Remove redundant files that have been created
if os.path.exists(filename):
os.remove(filename)
if os.path.exists(filename + '.idx'):
os.remove(filename + '.idx')
#Compute SOAP descriptor
struct.set_cutoff(desc.cutoff())
struct.calc_connect()
SOAP_descriptor = desc.calc(struct)['descriptor']
if self.average_over_permuations:
#average over different orders
SOAP_proto_averaged = np.zeros(SOAP_descriptor.size)
SOAP_proto_copy = SOAP_descriptor
for i in range(self.number_averages):
np.random.shuffle(SOAP_proto_copy)
SOAP_proto_averaged = np.add(SOAP_proto_averaged,
SOAP_proto_copy.flatten())
SOAP_proto_averaged = np.array(
[x / float(self.number_averages) for x in SOAP_proto_averaged])
SOAP_descriptor = SOAP_proto_averaged
if self.average:
SOAP_descriptor = SOAP_descriptor.flatten(
) # if get averaged LAE, then default output shape is (1,316), hence flatten()
descriptor_data = dict(descriptor_name=self.name,
descriptor_info=str(self),
SOAP_descriptor=SOAP_descriptor)
structure.info['descriptor'] = descriptor_data
return structure
def write(self, outfile: Union[bytes, str]):
"""
Writes BaseDataContainer object to file.
Parameters
----------
outfile
file to which to write
"""
self._metadata['date_last_backup'] = datetime.now().strftime(
'%Y-%m-%dT%H:%M:%S')
# Save reference atomic structure
reference_structure_file = tempfile.NamedTemporaryFile()
ase_write(reference_structure_file.name, self.structure, format='json')
# Save reference data
data_container_type = str(self.__class__).split('.')[-1].replace(
"'>", '')
reference_data = {
'parameters': self._ensemble_parameters,
'metadata': self._metadata,
'last_state': self._last_state,
'data_container_type': data_container_type
}
reference_data_file = tempfile.NamedTemporaryFile()
with open(reference_data_file.name, 'w') as fileobj:
json.dump(reference_data, fileobj, cls=Int64Encoder)
# Save runtime data
runtime_data_file = tempfile.NamedTemporaryFile()
np.savez_compressed(runtime_data_file, self._data_list)
# Write temporary tar file
with tempfile.NamedTemporaryFile('wb', delete=False) as f:
with tarfile.open(fileobj=f, mode='w') as handle:
handle.add(reference_data_file.name, arcname='reference_data')
handle.add(reference_structure_file.name, arcname='atoms')
handle.add(runtime_data_file.name, arcname='runtime_data')
# Copy to permanent location
file_name = f.name
f.close() # Required for Windows
shutil.copy(file_name, outfile)
os.remove(file_name)
runtime_data_file.close()
def write_image(path, data, options=None):
#file_path = './img/' + path
file_path = path
directory = file_path[:file_path.rfind('/')]
if not os.path.exists(directory):
os.makedirs(directory)
if isinstance(data, ModuleType):
if data.__name__ == "matplotlib.pyplot":
data.savefig(file_path)
elif isinstance(data, Atoms):
#file_path += '.png'
ase_write(file_path, data)
else:
print("No functionality for type = {}".format(type(data)))
return '[[' + file_path + ']]'
def write(self):
if os.path.exists(self.fn) and not self.opts.overwrite:
self.logger.error('Not overwriting %s' % self.fn)
else:
self.logger.info('Writing to: %s' % self.fn)
with open(self.fn, 'w') as fh:
self._writehead(fh)
self._writezmat(fh)
self._writetail(fh)
if self.opts.writeelectrodes:
self.writeelectrodes()
if self.opts.png:
self.logger.info('Writing %s.png' % self.jobname)
try:
# pass
ase_write('%s.png' % self.jobname,
self.parser.zmat,
rotation='90y')
except ValueError as msg:
self.logger.warn("Error writing png file: %s" % str(msg))
except TypeError as msg:
self.logger.warn("Error writing png file %s" % str(msg))
except ImportError as msg:
self.logger.error("Error importing _png module %s", str(msg))
def write(file_path, ase_atoms, file_format=None):
ase_write(file_path, ase_atoms, format=file_format)
def write_poscar(self, oposcar, oformat="vasp"):
ase_write(oposcar, self.internal_geometry,
format=oformat)
from ase.build import fcc111
from ase.io import write as ase_write
from ase.visualize import view
symbol = 'Au'
size = (10, 10, 3)
surface = fcc111(symbol,
size,
a=None,
vacuum=10.0,
orthogonal=True,
periodic=False)
surface.center()
view(surface)
ase_write('surface.xyz', surface)
