pyiron_atomistics.lammps.lammps.Lammps

pyiron_atomistics.lammps.lammps.Lammps#

class pyiron_atomistics.lammps.lammps.Lammps(project, job_name)[source]#

Bases: LammpsInteractive

Class to setup and run and analyze LAMMPS simulations.

Example:

>>> job = pr.create.job.Lammps(job_name='lmp_example')
>>> job.structure = pr.create.structure.bulk('Fe', cubic=True)
>>> job.run()

How to set potential: Look up potentials via job.view_potentials() (detailed data frame) or via job.list_potentials() (potential names). Assign the potential e.g. via:

>>> job.potential = job.list_potentials()[0]

Lammps has 3 modes: static, md and minimize. Set a mode e.g. via:

>>> job.calc_minimize()

Parameters:

project (pyiron_atomistics.project.Project instance) – Specifies the project path among other attributes
job_name (str) – Name of the job

input#

Instance which handles the input

Type:: lammps.Input instance

__init__(project, job_name)[source]#

Methods

`__init__`(project, job_name)
`animate_structure`([spacefill, show_cell, ...])	Animates the job if a trajectory is present
`animate_structures`([spacefill, show_cell, ...])	Animate a series of atomic structures.
`calc_md`([temperature, pressure, ...])	Set an MD calculation within LAMMPS.
`calc_minimize`([ionic_energy_tolerance, ...])	Sets parameters required for minimization.
`calc_static`()	Returns:
`calc_vcsgc`([mu, target_concentration, ...])	Run variance-constrained semi-grand-canonical MD/MC for a binary system.
`check_if_job_exists`([job_name, project])	Check if a job already exists in an specific project.
`check_setup`()	Checks whether certain parameters (such as plane wave cutoff radius in DFT) are changed from the pyiron standard values to allow for a physically meaningful results.
`clear_bonds`()	Clears all pre-defined bonds
`clear_job`()	Convenience function to clear job info after suspend.
`collect_logfiles`()	Returns:
`collect_output`()	Collect the output files of the external executable and store the information in the HDF5 file.
`collect_structures`([filter_function])	Collects a copy of all structures in a compact `StructureStorage`.
`compress`([files_to_compress])	Compress the output files of a job object.
`continue_with_final_structure`([job_type, ...])	param job_type:
`continue_with_restart_files`([job_type, job_name])	param job_type:
`convergence_check`()	Validate the convergence of the calculation.
`copy`()	Copy the GenericJob object which links to the job and its HDF5 file
`copy_file_to_working_directory`(file)	Copy a specific file to the working directory before the job is executed.
`copy_template`([project, new_job_name])	Copy the content of the job including the HDF5 file but without the output data to a new location
`copy_to`([project, new_job_name, input_only, ...])	Copy the content of the job including the HDF5 file to a new location.
`create_job`(job_type, job_name[, ...])	Create one of the following jobs: - 'StructureContainer’: - ‘StructurePipeline’: - ‘AtomisticExampleJob’: example job just generating random number - ‘ExampleJob’: example job just generating random number - ‘Lammps’: - ‘KMC’: - ‘Sphinx’: - ‘Vasp’: - ‘GenericMaster’: - ‘ParallelMaster’: series of jobs run in parallel - ‘KmcMaster’: - ‘ThermoLambdaMaster’: - ‘RandomSeedMaster’: - ‘MeamFit’: - ‘Murnaghan’: - ‘MinimizeMurnaghan’: - ‘ElasticMatrix’: - ‘ConvergenceEncutParallel’: - ‘ConvergenceKpointParallel’: - ’PhonopyMaster’: - ‘DefectFormationEnergy’: - ‘LammpsASE’: - ‘PipelineMaster’: - ’TransformationPath’: - ‘ThermoIntEamQh’: - ‘ThermoIntDftEam’: - ‘ScriptJob’: Python script or jupyter notebook job container - ‘ListMaster': list of jobs
`create_pipeline`(step_lst[, delete_existing_job])	Create a job pipeline
`db_entry`()	Generate the initial database entry
`decompress`()	Decompress the output files of a compressed job object.
`define_bonds`(species, element_list, ...[, ...])	Define the nature of bonds between different species.
`drop_status_to_aborted`()	Change the job status to aborted when the job was intercepted.
`enable_h5md`()	Returns:
`from_dict`(obj_dict)	Populate the object from the serialized object.
`from_hdf`([hdf, group_name])	Recreates instance from the hdf5 file
`from_hdf_args`(hdf)	Read arguments for instance creation from HDF5 file
`get`(name[, default])	Internal wrapper function for __getitem__() - self[name]
`get_calculate_function`()	Generate calculate() function
`get_final_structure`()	Returns:
`get_from_table`(path, name)	Get a specific value from a pandas.Dataframe
`get_input_parameter_dict`()	Get an hierarchical dictionary of input files.
`get_job_id`([job_specifier])	get the job_id for job named job_name in the local project path from database
`get_neighbors`([start, stop, stride, ...])	Get the neighbors for a given section of the trajectory
`get_neighbors_snapshots`([snapshot_indices, ...])	Get the neighbors only for the required snapshots from the trajectory
`get_output_parameter_dict`()
`get_potentials_for_structure`()	Returns:
`get_structure`([frame, wrap_atoms, ...])	Retrieve structure from object.
`get_workdir_file`(filename)	Checks if a given file exists within the job's working directory and returns the absolute path to it.
`gui`()	Returns:
`inspect`(job_specifier)	Inspect an existing pyiron object - most commonly a job - from the database
`instantiate`(obj_dict[, version])	Create a blank instance of this class.
`interactive_atom_spin_constraints_getter`()
`interactive_atom_spins_getter`()
`interactive_cell_organizer`()
`interactive_cells_getter`()
`interactive_cells_setter`(cell)
`interactive_close`()	For jobs which executables are available as Python library, those can also be executed with a library call instead of calling an external executable.
`interactive_collect`()
`interactive_computation_time_getter`()
`interactive_energy_pot_getter`()
`interactive_energy_tot_getter`()
`interactive_execute`()
`interactive_fetch`()	For jobs which executables are available as Python library, those can also be executed with a library call instead of calling an external executable.
`interactive_flush`([path, include_last_step])	param path:
`interactive_forces_getter`()
`interactive_index_organizer`()
`interactive_indices_getter`()
`interactive_indices_setter`(indices)
`interactive_initialize_interface`()
`interactive_is_activated`()	Check if the interactive library is activated.
`interactive_magmom_organizer`()
`interactive_magnetic_forces_getter`()
`interactive_open`()	Set the run mode to interactive.
`interactive_positions_getter`()
`interactive_positions_organizer`()
`interactive_positions_setter`(positions)
`interactive_pressures_getter`()
`interactive_spin_constraints_getter`()
`interactive_spin_constraints_setter`(spins)
`interactive_spins_getter`()
`interactive_steps_getter`()
`interactive_store_in_cache`(key, value)	Store a value in the interactive cache.
`interactive_stress_getter`()	This gives back an Nx3x3 array of stress/atom defined in http://lammps.sandia.gov/doc/compute_stress_atom.html Keep in mind that it is stress*volume in eV.
`interactive_structure_setter`(structure)
`interactive_temperatures_getter`()
`interactive_time_getter`()
`interactive_unwrapped_positions_getter`()
`interactive_volume_getter`()
`is_compressed`()	Check if the job is already compressed or not.
`is_master_id`(job_id)	Check if the job ID job_id is the master ID for any child job
`is_self_archived`()	Check if the HDF5 file of the Job is compressed as tar-archive
`iter_structures`([wrap_atoms])	Iterate over all structures in this object.
`job_file_name`(file_name[, cwd])	combine the file name file_name with the path of the current working directory
`kill`()	Kill the job.
`list_all`()	Returns dictionary of :method:`.list_groups()` and :method:`.list_nodes()`.
`list_childs`()	List child jobs as JobPath objects - not loading the full GenericJob objects for each child
`list_files`()	List files inside the working directory
`list_groups`()	Return a list of names of all nested groups.
`list_nodes`()	Return a list of names of all nested nodes.
`list_potentials`()	List of interatomic potentials suitable for the current atomic structure.
`load`(job_specifier[, convert_to_object])	Load an existing pyiron object - most commonly a job - from the database
`map`(function, parameter_lst)	Create `MapMaster` with the current job as reference job.
`move_to`(project)	Move the content of the job including the HDF5 file to a new location
`next`([job_name, job_type])	Restart a new job created from an existing Lammps calculation.
`read_restart_file`([filename])	param filename:
`refresh_job_status`()	Refresh job status by updating the job status with the status from the database if a job ID is available.
`relocate_hdf5`([h5_path])	Relocate the hdf file.
`remap_indices`(lammps_indices)	Give the Lammps-dumped indices, re-maps these back onto the structure's indices to preserve the species.
`remove`([_protect_childs])	Remove the job - this removes the HDF5 file, all data stored in the HDF5 file an the corresponding database entry.
`remove_and_reset_id`([_protect_childs])	Remove the job and reset its ID.
`remove_child`()	internal function to remove command that removes also child jobs.
`rename`(new_job_name)	Rename the job - by changing the job name
`reset_job_id`([job_id])	Reset the job id sets the job_id to None in the GenericJob as well as all connected modules like JobStatus.
`restart`([job_name, job_type])	Restart a new job created from an existing Lammps calculation.
`run`([delete_existing_job, repair, debug, ...])	This is the main run function, depending on the job status ['initialized', 'created', 'submitted', 'running', 'collect','finished', 'refresh', 'suspended'] the corresponding run mode is chosen.
`run_if_interactive`()	For jobs which executables are available as Python library, those can also be executed with a library call instead of calling an external executable.
`run_if_interactive_non_modal`()	For jobs which executables are available as Python library, those can also be executed with a library call instead of calling an external executable.
`run_if_modal`()	The run if modal function is called by run to execute the simulation, while waiting for the output.
`run_if_refresh`()	Internal helper function the run if refresh function is called when the job status is 'refresh'.
`run_if_scheduler`()	The run if queue function is called by run if the user decides to submit the job to and queing system.
`run_static`()	The run static function is called by run to execute the simulation.
`run_time_to_db`()	Internal helper function to store the run_time in the database
`save`()	Save the object, by writing the content to the HDF5 file and storing an entry in the database.
`save_output`([output_dict, shell_output])	Store output of the calculate function in the HDF5 file.
`self_archive`()	Compress HDF5 file of the job object to tar-archive
`self_unarchive`()	Decompress HDF5 file of the job object from tar-archive
`set_fix_external`(function[, n_call, ...])	Expert feature *
`set_input_to_read_only`()	This function enforces read-only mode for the input classes, but it has to be implement in the individual classes.
`set_potential`(file_name)	param file_name:
`show_hdf`()	Iterating over the HDF5 datastructure and generating a human readable graph.
`signal_intercept`(sig)	Abort the job and log signal that caused it.
`species_from_hdf`()
`store_structure`()	Create `StructureContainer` job with the initial structure of the job and sets that jobs `parent_id` from this job.
`suspend`()	Suspend the job by storing the object and its state persistently in HDF5 file and exit it.
`to_dict`()	Reduce the object to a dictionary.
`to_hdf`([hdf, group_name])	Store the InteractiveBase object in the HDF5 File
`to_object`([object_type])	Load the full pyiron object from an HDF5 file
`trajectory`([stride, center_of_mass, ...])	Returns a Trajectory instance containing the necessary information to describe the evolution of the atomic structure during the atomistic simulation.
`transfer_from_remote`()	Transfer the job from a remote location to the local machine.
`transform_structures`(modify)	Return a modified object by applying a function to each object lazily.
`update_master`([force_update])	After a job is finished it checks whether it is linked to any metajob - meaning the master ID is pointing to this jobs job ID.
`update_potential`()
`validate_ready_to_run`()	Validating input parameters before LAMMPS run
`view_potentials`()	List all interatomic potentials for the current atomistic structure including all potential parameters.
`view_structure`([snapshot, spacefill, show_cell])	param snapshot: Snapshot of the trajectory one wants
`write_input`()	Call routines that generate the code specific input files Returns:
`write_restart_file`([filename])	param filename:
`write_traj`(filename[, file_format, ...])	Writes the trajectory in a given file file_format based on the ase.io.write function.

Attributes

`bond_dict`	A dictionary which defines the nature of LAMMPS bonds that are to be drawn between atoms.
`calculate_kwargs`	Generate keyword arguments for the calculate() function.
`child_ids`	list of child job ids - only meta jobs have child jobs - jobs which list the meta job as their master
`content`
`current_structure`
`cutoff_radius`	Returns:
`database_entry`
`exclude_groups_hdf`	Get the list of groups which are excluded from storing in the hdf5 file
`exclude_nodes_hdf`	Get the list of nodes which are excluded from storing in the hdf5 file
`executable`	Get the executable used to run the job - usually the path to an external executable.
`executor_type`
`files`	Allows to browse the files in a job directory.
`files_to_compress`
`files_to_remove`
`id`	Unique id to identify the job in the pyiron database - use self.job_id instead
`initial_structure`
`interactive_enforce_structure_reset`
`interactive_flush_frequency`
`interactive_mpi_communicator`
`interactive_water_bonds`
`interactive_write_frequency`
`job_id`	Unique id to identify the job in the pyiron database
`job_info_str`	Short string to describe the job by it is job_name and job ID - mainly used for logging
`job_name`	Get name of the job, which has to be unique within the project
`job_type`	['ExampleJob', 'ParallelMaster', 'ScriptJob',
`logger`	Get the logger object to monitor the external execution and internal pyiron warnings.
`master_id`	Get job id of the master job - a meta job which groups a series of jobs, which are executed either in parallel or in serial.
`name`	Get name of the job, which has to be unique within the project
`number_of_structures`	maximum iteration_step + 1 that can be passed to `get_structure()`.
`parent_id`	Get job id of the predecessor job - the job which was executed before the current one in the current job series
`path`	Absolute path of the HDF5 group starting from the system root - combination of the absolute system path plus the absolute path inside the HDF5 file starting from the root group.
`potential`	Execute view_potentials() or list_potentials() in order to see the pre-defined potential files
`potential_available`
`potential_list`	List of interatomic potentials suitable for the current atomic structure.
`potential_view`	List all interatomic potentials for the current atomistic sturcture including all potential parameters.
`project`	Project instance the jobs is located in
`project_hdf5`	Get the ProjectHDFio instance which points to the HDF5 file the job is stored in
`publication`
`queue_id`	Get the queue ID, the ID returned from the queuing system - it is most likely not the same as the job ID.
`restart_file_dict`	A dictionary of the new name of the copied restart files
`restart_file_list`	Get the list of files which are used to restart the calculation from these files.
`server`	Get the server object to handle the execution environment for the job.
`status`	Execution status of the job, can be one of the following [initialized, appended, created, submitted, running,
`structure`	Returns:
`units`	Type of LAMMPS units used in the calculations.
`version`	Get the version of the hamiltonian, which is also the version of the executable unless a custom executable is used.
`working_directory`	Get the working directory of the job is executed in - outside the HDF5 file. The working directory equals the path but it is represented by the filesystem: /absolute/path/to/the/file.h5/path/inside/the/hdf5/file becomes: /absolute/path/to/the/file_hdf5/path/inside/the/hdf5/file.

animate_structure(spacefill: bool = True, show_cell: bool = True, stride: int = 1, center_of_mass: bool = False, particle_size: float = 0.5, camera: str = 'orthographic', atom_indices: list | ndarray = None, snapshot_indices: list | ndarray = None, repeat: int | Tuple[int, int, int] = None)#

Animates the job if a trajectory is present

Parameters:

spacefill (bool) – If True, then atoms are visualized in spacefill stype
show_cell (bool) – True if the cell boundaries of the structure is to be shown
stride (int) –
show animation every stride [::stride] use value >1 to make animation faster

default=1
particle_size (float) – Scaling factor for the spheres representing the atoms. (The radius is determined by the atomic number)
center_of_mass (bool) – False (default) if the specified positions are w.r.t. the origin
camera (str) – camera perspective, choose from “orthographic” or “perspective”
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
repeat (int/3-tuple of int) – Repeat the structures by this before animating

Returns:

nglview IPython widget

Return type:

animation

animate_structures(spacefill: bool = True, show_cell: bool = True, center_of_mass: bool = False, particle_size: float = 0.5, camera: str = 'orthographic')#

Animate a series of atomic structures.

Parameters:

spacefill (bool) – If True, then atoms are visualized in spacefill stype
show_cell (bool) – True if the cell boundaries of the structure is to be shown
particle_size (float) – Scaling factor for the spheres representing the atoms. (The radius is determined by the atomic number)
center_of_mass (bool) – False (default) if the specified positions are w.r.t. the origin
camera (str) – camera perspective, choose from “orthographic” or “perspective”

Returns:

nglview IPython widget

Return type:

animation

property bond_dict#

A dictionary which defines the nature of LAMMPS bonds that are to be drawn between atoms. To set the values, use the function define_bonds.

Returns:: Dictionary of the bond properties for every species
Return type:: dict

calc_md(temperature=None, pressure=None, n_ionic_steps=1000, time_step=1.0, n_print=100, temperature_damping_timescale=100.0, pressure_damping_timescale=1000.0, seed=None, tloop=None, initial_temperature=None, langevin=False, delta_temp=None, delta_press=None)#

Set an MD calculation within LAMMPS. Nosé Hoover is used by default.

Parameters:

temperature (None/float/list) – Target temperature value(-s). If set to None, an NVE calculation is performed. It is required when the pressure is set or langevin is set It can be a list of temperature values, containing the initial target temperature and the final target temperature (in between the target value is varied linearly).
pressure (None/float/numpy.ndarray/list) – Target pressure. If set to None, an NVE or an NVT calculation is performed. If set to a scalar, the shear of the cell and the ratio of the x, y, and z components is kept constant, while an isotropic, hydrostatic pressure is applied. A list of up to length 6 can be given to specify xx, yy, zz, xy, xz, and yz components of the pressure tensor, respectively. These values can mix floats and None to allow only certain degrees of cell freedom to change. (Default is None, run isochorically.)
n_ionic_steps (int) – Number of ionic steps
time_step (float) – Step size in fs between two steps.
n_print (int) – Print frequency
temperature_damping_timescale (float) – The time associated with the thermostat adjusting the temperature. (In fs. After rescaling to appropriate time units, is equivalent to Lammps’ Tdamp.)
pressure_damping_timescale (float) – The time associated with the barostat adjusting the temperature. (In fs. After rescaling to appropriate time units, is equivalent to Lammps’ Pdamp.)
seed (int) – Seed for the random number generation used for the intiial velocity creation and langevin dynamics - otherwise ignored. If not specified, the seed is created via job name
tloop
initial_temperature (None/float) – Initial temperature according to which the initial velocity field is created. If None, the initial temperature will be twice the target temperature (which would go immediately down to the target temperature as described in equipartition theorem). If 0, the velocity field is not initialized (in which case the initial velocity given in structure will be used). If any other number is given, this value is going to be used for the initial temperature.
langevin (bool) – (True or False) Activate Langevin dynamics
delta_temp (float) – Thermostat timescale, but in your Lammps time units, whatever those are. (DEPRECATED.)
delta_press (float) – Barostat timescale, but in your Lammps time units, whatever those are. (DEPRECATED.)
job_name (str) – Job name of the job to generate a unique random seed.
rotation_matrix (numpy.ndarray) – The rotation matrix from the pyiron to Lammps coordinate frame.

calc_minimize(ionic_energy_tolerance=0.0, ionic_force_tolerance=0.0001, e_tol=None, f_tol=None, max_iter=100000, pressure=None, n_print=100, style='cg')#

Sets parameters required for minimization.

Parameters:

ionic_energy_tolerance (float) – If the magnitude of difference between energies of two consecutive steps is lower than or equal to ionic_energy_tolerance, the minimisation terminates. (Default is 0.0 eV.)
ionic_force_tolerance (float) – If the magnitude of the global force vector at a step is lower than or equal to ionic_force_tolerance, the minimisation terminates. (Default is 1e-4 eV/angstrom.)
e_tol (float) – Same as ionic_energy_tolerance (deprecated)
f_tol (float) – Same as ionic_force_tolerance (deprecated)
max_iter (int) – Maximum number of minimisation steps to carry out. If the minimisation converges before max_iter steps, terminate at the converged step. If the minimisation does not converge up to max_iter steps, terminate at the max_iter step. (Default is 100000.)
pressure (None/float/numpy.ndarray/list) – Target pressure. If set to None, an isochoric (constant V) calculation is performed. If set to a scalar, the shear of the cell and the ratio of the x, y, and z components is kept constant, while an isotropic, hydrostatic pressure is applied. A list of up to length 6 can be given to specify xx, yy, zz, xy, xz, and yz components of the pressure tensor, respectively. These values can mix floats and None to allow only certain degrees of cell freedom to change. (Default is None, run isochorically.)
n_print (int) – Write (dump or print) to the output file every n steps (Default: 100)
style ('cg'/'sd'/other values from Lammps docs) – The style of the numeric minimization, either conjugate gradient, steepest descent, or other keys permissible from the Lammps docs on ‘min_style’. (Default is ‘cg’ – conjugate gradient.)
rotation_matrix (numpy.ndarray) – The rotation matrix from the pyiron to Lammps coordinate frame.

calc_static()#: Returns:

calc_vcsgc(mu=None, target_concentration=None, kappa=1000.0, mc_step_interval=100, swap_fraction=0.1, temperature_mc=None, window_size=None, window_moves=None, temperature=None, pressure=None, n_ionic_steps=1000, time_step=1.0, n_print=100, temperature_damping_timescale=100.0, pressure_damping_timescale=1000.0, seed=None, initial_temperature=None, langevin=False)#

Run variance-constrained semi-grand-canonical MD/MC for a binary system. In addition to VC-SGC arguments, all arguments for a regular MD calculation are also accepted.

https://vcsgc-lammps.materialsmodeling.org

Note

For easy visualization later (with get_structure), it is highly recommended that the initial structure contain at least one atom of each species.

Warning

The fix does not yet support non-orthogonal simulation boxes; using one will give a runtime error.

Parameters:

mu (dict) – A dictionary of chemical potentials, one for each element the potential treats, where the dictionary keys are just the chemical symbol. Note that only the relative chemical potentials are used here, such that the swap acceptance probability is influenced by the chemical potential difference between the two species (a more negative value increases the odds of swapping to that element.) (Default is None, all elements have the same chemical potential.)
target_concentration – A dictionary of target simulation domain concentrations for each species in the potential. Dictionary keys should be the chemical symbol of the corresponding species, and the sum of all concentrations must be 1. (Default is None, which runs regular semi-grand-canonical MD/MC without any variance constraint.)
kappa – Variance constraint for the MC. Larger value means a tighter adherence to the target concentrations. (Default is 1000.)
mc_step_interval (int) – How many steps of MD between each set of MC moves. (Default is 100.) Must divide the number of ionic steps evenly.
swap_fraction (float) – The fraction of atoms whose species is swapped at each MC phase. (Default is 0.1.)
temperature_mc (float) – The temperature for accepting MC steps. (Default is None, which uses the MD temperature.)
window_size (float) – The size of the sampling window for parallel calculations as a fraction of something unspecified in the VC-SGC docs, but it must lie between 0.5 and 1. (Default is None, window is determined automatically.)
window_moves (int) – The number of times the sampling window is moved during one MC cycle. (Default is None, number of moves is determined automatically.)

property calculate_kwargs: dict#

Generate keyword arguments for the calculate() function. A new simulation code only has to extend the get_input_parameter_dict() function which by default specifies an hierarchical dictionary with files_to_write and files_to_copy.

Example:

>>> calculate_function = job.get_calculate_function()
>>> shell_output, parsed_output, job_crashed = calculate_function(**job.calculate_kwargs)
>>> job.save_output(output_dict=parsed_output, shell_output=shell_output)

Returns:: keyword arguments for the calculate() function
Return type:: dict

check_if_job_exists(job_name: str | None = None, project: ProjectHDFio | pyiron_base.project.generic.Project | None = None)#

Check if a job already exists in an specific project.

Parameters:

job_name (str) – Job name (optional)
project (ProjectHDFio, Project) – Project path (optional)

Returns:

True / False

Return type:

(bool)

check_setup() → None#: Checks whether certain parameters (such as plane wave cutoff radius in DFT) are changed from the pyiron standard values to allow for a physically meaningful results. This function is called manually or only when the job is submitted to the queueing system.

property child_ids: list#

list of child job ids - only meta jobs have child jobs - jobs which list the meta job as their master

Returns:: list of child job ids
Return type:: list

clear_bonds() → None#: Clears all pre-defined bonds

clear_job() → None#: Convenience function to clear job info after suspend. Mimics deletion of all the job info after suspend in a local test environment.

collect_logfiles()#: Returns:

collect_output() → None#: Collect the output files of the external executable and store the information in the HDF5 file. This method has to be implemented in the individual hamiltonians.

collect_structures(filter_function=None) → StructureStorage#

Collects a copy of all structures in a compact StructureStorage.

This can be used to force lazily applied modifications with transform_structures() or simply to obtain a known object type from a generic HasStructure object.

Parameters:: filter_function (function) – include structure only if this function returns True for it
Returns:: a copy of all (filtered) structures
Return type:: StructureStorage

compress(files_to_compress=None)#

Compress the output files of a job object.

Parameters:: files_to_compress (list)

continue_with_final_structure(job_type=None, job_name=None)#

Parameters:

job_type
job_name

Returns:

continue_with_restart_files(job_type=None, job_name=None)#

Parameters:

job_type
job_name

Returns:

convergence_check()#

Validate the convergence of the calculation.

Returns:: If the calculation is converged
Return type:: (bool)

copy() → GenericJob#

Copy the GenericJob object which links to the job and its HDF5 file

Returns:: New GenericJob object pointing to the same job
Return type:: GenericJob

copy_file_to_working_directory(file: str) → None#

Copy a specific file to the working directory before the job is executed.

Parameters:: file (str) – path of the file to be copied.

copy_template(project: ProjectHDFio | JobCore | None = None, new_job_name: None = None) → GenericJob#

Copy the content of the job including the HDF5 file but without the output data to a new location

Parameters:

project (JobCore/ProjectHDFio/Project/None) – The project to copy the job to. (Default is None, use the same project.)
new_job_name (str) – The new name to assign the duplicate job. Required if the project is None or the same project as the copied job. (Default is None, try to keep the same name.)

Returns:

GenericJob object pointing to the new location.

Return type:

GenericJob

copy_to(project: ProjectHDFio | JobCore | None = None, new_job_name: str | None = None, input_only: bool = False, new_database_entry: bool = True, delete_existing_job: bool = False, copy_files: bool = True)#

Copy the content of the job including the HDF5 file to a new location.

Parameters:

project (JobCore/ProjectHDFio/Project/None) – The project to copy the job to. (Default is None, use the same project.)
new_job_name (str) – The new name to assign the duplicate job. Required if the project is None or the same project as the copied job. (Default is None, try to keep the same name.)
input_only (bool) – [True/False] Whether to copy only the input. (Default is False.)
new_database_entry (bool) – [True/False] Whether to create a new database entry. If input_only is True then new_database_entry is False. (Default is True.)
delete_existing_job (bool) – [True/False] Delete existing job in case it exists already (Default is False.)
copy_files (bool) – If True copy all files the working directory of the job, too

Returns:

GenericJob object pointing to the new location.

Return type:

GenericJob

create_job(job_type: str, job_name: str, delete_existing_job: bool = False) → GenericJob#

Create one of the following jobs: - ‘StructureContainer’: - ‘StructurePipeline’: - ‘AtomisticExampleJob’: example job just generating random number - ‘ExampleJob’: example job just generating random number - ‘Lammps’: - ‘KMC’: - ‘Sphinx’: - ‘Vasp’: - ‘GenericMaster’: - ‘ParallelMaster’: series of jobs run in parallel - ‘KmcMaster’: - ‘ThermoLambdaMaster’: - ‘RandomSeedMaster’: - ‘MeamFit’: - ‘Murnaghan’: - ‘MinimizeMurnaghan’: - ‘ElasticMatrix’: - ‘ConvergenceEncutParallel’: - ‘ConvergenceKpointParallel’: - ’PhonopyMaster’: - ‘DefectFormationEnergy’: - ‘LammpsASE’: - ‘PipelineMaster’: - ’TransformationPath’: - ‘ThermoIntEamQh’: - ‘ThermoIntDftEam’: - ‘ScriptJob’: Python script or jupyter notebook job container - ‘ListMaster’: list of jobs

Parameters:

job_type (str) – job type can be [‘StructureContainer’, ‘StructurePipeline’, ‘AtomisticExampleJob’, ‘ExampleJob’, ‘Lammps’, ‘KMC’, ‘Sphinx’, ‘Vasp’, ‘GenericMaster’, ‘ParallelMaster’, ‘KmcMaster’, ‘ThermoLambdaMaster’, ‘RandomSeedMaster’, ‘MeamFit’, ‘Murnaghan’, ‘MinimizeMurnaghan’, ‘ElasticMatrix’, ‘ConvergenceEncutParallel’, ‘ConvergenceKpointParallel’, ’PhonopyMaster’, ‘DefectFormationEnergy’, ‘LammpsASE’, ‘PipelineMaster’, ’TransformationPath’, ‘ThermoIntEamQh’, ‘ThermoIntDftEam’, ‘ScriptJob’, ‘ListMaster’]
job_name (str) – name of the job
delete_existing_job (bool) – delete an existing job - default false

Returns:

job object depending on the job_type selected

Return type:

GenericJob

create_pipeline(step_lst, delete_existing_job=False)#

Create a job pipeline

Parameters:: step_lst (list) – List of functions which create calculations
Return type:: FlexibleMaster

property cutoff_radius#: Returns:

db_entry()#

Generate the initial database entry

Returns:: db_dict
Return type:: (dict)

decompress() → None#: Decompress the output files of a compressed job object.

define_bonds(species, element_list, cutoff_list, max_bond_list, bond_type_list, angle_type_list=None)#

Define the nature of bonds between different species. Make sure that the bonds between two species are defined only once (no double counting).

Parameters:

species (str) – Species for which the bonds are to be drawn (e.g. O, H, C ..)
element_list (list) – List of species to which the bonds are to be made (e.g. O, H, C, ..)
cutoff_list (list) – Draw bonds only for atoms within this cutoff distance
max_bond_list (list) – Maximum number of bonds drawn from each molecule
bond_type_list (list) – Type of the bond as defined in the LAMMPS potential file
angle_type_list (list) – Type of the angle as defined in the LAMMPS potential file

Example

The command below defined bonds between O and H atoms within a cutoff raduis of 2 $AA$ with the bond and angle types 1 defined in the potential file used

>> job_lammps.define_bonds(species=”O”, element_list-[“H”], cutoff_list=[2.0], bond_type_list=[1], angle_type_list=[1])

drop_status_to_aborted() → None#: Change the job status to aborted when the job was intercepted.

enable_h5md()#: Returns:

property exclude_groups_hdf: list#

Get the list of groups which are excluded from storing in the hdf5 file

Returns:: groups(list)

property exclude_nodes_hdf: list#

Get the list of nodes which are excluded from storing in the hdf5 file

Returns:: nodes(list)

property executable: Executable#

Get the executable used to run the job - usually the path to an external executable.

Returns:: exectuable path
Return type:: (str/pyiron_base.job.executable.Executable)

property files: FileBrowser#

Allows to browse the files in a job directory.

By default this object prints itself as a listing of the job directory and the files inside.
>>> job.files
/path/to/my/job:
    pyiron.log
    error.out
Access to the names of files is provided with list()
>>> job.files.list()
['pyiron.log', 'error.out', 'INCAR']
Access to the contents of files is provided by indexing into this object, which returns a list of lines in the file
>>> job.files['error.out']
["Oh no

“, “Something went wrong! “]

The tail() method prints the last lines of a file to stdout
>>> job.files.tail('error.out', lines=1)
Something went wrong!
For files that have valid python variable names can also be accessed by attribute notation
>>> job.files.INCAR 
File('INCAR')

from_dict(obj_dict)#

Populate the object from the serialized object.

Parameters:

obj_dict (dict) – data previously returned from to_dict()
version (str) – version tag written together with the data

from_hdf(hdf=None, group_name=None)#

Recreates instance from the hdf5 file

Parameters:

hdf (str) – Path to the hdf5 file
group_name (str) – Name of the group which contains the object

classmethod from_hdf_args(hdf: ProjectHDFio) → dict#

Read arguments for instance creation from HDF5 file

Parameters:: hdf (ProjectHDFio) – HDF5 group object

get(name: str, default: Any | None = None) → Any#

Internal wrapper function for __getitem__() - self[name]

Parameters:

key (str, slice) – path to the data or key of the data object
default (any, optional) – return this if key cannot be found

Returns:

data or data object

Return type:

dict, list, float, int

Raises:

ValueError – key cannot be found and default is not given

get_calculate_function() → callable#

Generate calculate() function

Example:

>>> calculate_function = job.get_calculate_function()
>>> shell_output, parsed_output, job_crashed = calculate_function(**job.calculate_kwargs)
>>> job.save_output(output_dict=parsed_output, shell_output=shell_output)

Returns:: calculate() functione
Return type:: callable

get_final_structure()#: Returns:

get_from_table(path: str, name: str) → dict | list | float | int#

Get a specific value from a pandas.Dataframe

Parameters:

path (str) – relative path to the data object
name (str) – parameter key

Returns:

the value associated to the specific parameter key

Return type:

dict, list, float, int

get_input_parameter_dict()#

Get an hierarchical dictionary of input files. On the first level the dictionary is divided in file_to_create and files_to_copy. Both are dictionaries use the file names as keys. In file_to_create the values are strings which represent the content which is going to be written to the corresponding file. In files_to_copy the values are the paths to the source files to be copied.

The get_input_file_dict() function is called before the write_input() function to convert the input specified on the job object to strings which can be written to the working directory as well as files which are copied to the working directory. After the write_input() function wrote the input files the executable is called.

Returns:: hierarchical dictionary of input files
Return type:: dict

get_job_id(job_specifier: int | str | None = None) → int | None#

get the job_id for job named job_name in the local project path from database

Parameters:: job_specifier (str, int) – name of the job or job ID
Returns:: job ID of the job
Return type:: int

get_neighbors(start=0, stop=-1, stride=1, num_neighbors=12, **kwargs)#

Get the neighbors for a given section of the trajectory

Parameters:

start (int) – Start point of the slice of the trajectory to be sampled
stop (int) – End point of of the slice of the trajectory to be sampled
stride (int) – Samples the snapshots evert stride steps
num_neighbors (int) – The cutoff for the number of neighbors
**kwargs (dict) – Additional arguments to be passed to the get_neighbors() routine (eg. cutoff_radius, norm_order , etc.)

Returns:

NeighborsTraj instances: containing the neighbor information.

Return type:

pyiron_atomistics.atomistics.structure.neighbors.NeighborsTrajectory

get_neighbors_snapshots(snapshot_indices=None, num_neighbors=12, **kwargs)#

Get the neighbors only for the required snapshots from the trajectory

Parameters:

snapshot_indices (list/numpy.ndarray) – Snapshots for which the the neighbors need to be computed (eg. [1, 5, 10,…, 100]
num_neighbors (int) – The cutoff for the number of neighbors
**kwargs (dict) – Additional arguments to be passed to the get_neighbors() routine (eg. cutoff_radius, norm_order , etc.)

Returns:

NeighborsTraj instances: containing the neighbor information.

Return type:

pyiron_atomistics.atomistics.structure.neighbors.NeighborsTrajectory

get_potentials_for_structure()#: Returns:

get_structure(frame=-1, wrap_atoms=True, iteration_step=None)#

Retrieve structure from object. The number of available structures depends on the job and what kind of calculation has been run on it, see number_of_structures.

Parameters:: frame (int, object) – index of the structure requested, if negative count from the back; if

:param _translate_frame() is overridden: :param frame will pass through it: :param iteration_step: deprecated alias for frame :type iteration_step: int :param wrap_atoms: True if the atoms are to be wrapped back into the unit cell :type wrap_atoms: bool

Returns:: the requested structure
Return type:: pyiron_atomistics.atomistics.structure.atoms.Atoms
Raises:: IndexError – if not -number_of_structures <= iteration_step < number_of_structures

get_workdir_file(filename: str) → None#

Checks if a given file exists within the job’s working directory and returns the absolute path to it.

ToDo: Move this to pyiron_base since this is more generic.

Parameters:: filename (str) – The name of the file
Returns:: The name absolute path of the file in the working directory
Return type:: str
Raises:: FileNotFoundError – Raised if the given file does not exist.

gui()#: Returns:

property id: int#

Unique id to identify the job in the pyiron database - use self.job_id instead

Returns:: job id
Return type:: int

inspect(job_specifier: str | int) → JobCore#

Inspect an existing pyiron object - most commonly a job - from the database

Parameters:: job_specifier (str, int) – name of the job or job ID
Returns:: Access to the HDF5 object - not a GenericJob object - use load() instead.
Return type:: JobCore

classmethod instantiate(obj_dict: dict, version: str = None) → Self#

Create a blank instance of this class.

This can be used when some values are already necessary for the objects __init__.

Parameters:

obj_dict (dict) – data previously returned from to_dict()
version (str) – version tag written together with the data

Returns:

a blank instance of the object that is sufficiently initialized to call _from_dict() on it

Return type:

object

interactive_close()#: For jobs which executables are available as Python library, those can also be executed with a library call instead of calling an external executable. This is usually faster than a single core python job. After the interactive execution, the job can be closed using the interactive_close function.

interactive_fetch()#: For jobs which executables are available as Python library, those can also be executed with a library call instead of calling an external executable. This is usually faster than a single core python job. To access the output data during the execution the interactive_fetch function is used.

interactive_flush(path='interactive', include_last_step=False)#

Parameters:

path
include_last_step

Returns:

interactive_is_activated() → bool#

Check if the interactive library is activated.

Returns:: True if the interactive library is activated, False otherwise.
Return type:: bool

interactive_open() → pyiron_base.jobs.job.interactive.InteractiveBase#

Set the run mode to interactive.

This is the same as setting server.run_mode.interactive.

Must be called before run() is called.

interactive_store_in_cache(key: str, value: Any) → None#

Store a value in the interactive cache.

Parameters:

key (str) – The key to store the value under.
value (Any) – The value to be stored.

Returns:

None

interactive_stress_getter()#

This gives back an Nx3x3 array of stress/atom defined in http://lammps.sandia.gov/doc/compute_stress_atom.html Keep in mind that it is stress*volume in eV. Further discussion can be found on the website above.

Returns:: Nx3x3 np array of stress/atom
Return type:: numpy.array

is_compressed() → bool#

Check if the job is already compressed or not.

Returns:: [True/False]
Return type:: bool

is_master_id(job_id: int) → bool#

Check if the job ID job_id is the master ID for any child job

Parameters:: job_id (int) – job ID of the master job
Returns:: [True/False]
Return type:: bool

is_self_archived() → bool#

Check if the HDF5 file of the Job is compressed as tar-archive

Returns:: [True/False]
Return type:: bool

iter_structures(wrap_atoms=True)#

Iterate over all structures in this object.

Parameters:: wrap_atoms (bool) – True if the atoms are to be wrapped back into the unit cell; passed to get_structure()
Yields:: pyiron_atomistics.atomistitcs.structure.atoms.Atoms – every structure attached to the object

job_file_name(file_name: str, cwd: str | None = None) → str#

combine the file name file_name with the path of the current working directory

Parameters:

file_name (str) – name of the file
cwd (str) – current working directory - this overwrites self.project_hdf5.working_directory - optional

Returns:

absolute path to the file in the current working directory

Return type:

str

property job_id: int#

Unique id to identify the job in the pyiron database

Returns:: job id
Return type:: int

property job_info_str: str#

Short string to describe the job by it is job_name and job ID - mainly used for logging

Returns:: job info string
Return type:: str

property job_name: str#

Get name of the job, which has to be unique within the project

Returns:: job name
Return type:: str

property job_type: str#

[‘ExampleJob’, ‘ParallelMaster’, ‘ScriptJob’,: ‘ListMaster’]

Returns:: Job type object
Return type:: JobTypeChoice
Type:: Job type object with all the available job types

kill() → None#

Kill the job.

This function is used to terminate the execution of the job. It checks if the job is currently running or submitted, and if so, it removes and resets the job ID. If the job is not running or submitted, a ValueError is raised.

Returns:: None

list_all()#

Returns dictionary of :method:`.list_groups()` and :method:`.list_nodes()`.

Returns:

results of :method:`.list_groups() under the key "groups"; results of :method:`.list_nodes()` und the: key “nodes”

Return type:

dict

list_childs() → list#

List child jobs as JobPath objects - not loading the full GenericJob objects for each child

Returns:: list of child jobs
Return type:: list

list_files() → list#

List files inside the working directory

Parameters:: extension (str) – filter by a specific extension
Returns:: list of file names
Return type:: list

list_groups()#

Return a list of names of all nested groups.

Returns:: group names
Return type:: list of str

list_nodes()#

Return a list of names of all nested nodes.

Returns:: node names
Return type:: list of str

list_potentials() → list#

List of interatomic potentials suitable for the current atomic structure.

use self.view_potentials() to get more details.

Returns:: potential names
Return type:: list

load(job_specifier: str | int, convert_to_object: bool = True) → pyiron_base.job.generic.GenericJob | JobCore#

Load an existing pyiron object - most commonly a job - from the database

Parameters:

job_specifier (str, int) – name of the job or job ID
convert_to_object (bool) – convert the object to an pyiron object or only access the HDF5 file - default=True accessing only the HDF5 file is about an order of magnitude faster, but only provides limited functionality. Compare the GenericJob object to JobCore object.

Returns:

Either the full GenericJob object or just a reduced JobCore object

Return type:

GenericJob, JobCore

property logger#

Get the logger object to monitor the external execution and internal pyiron warnings.

Returns:: logger object
Return type:: logging.getLogger()

map(function, parameter_lst)#

Create MapMaster with the current job as reference job.

The job name is created as ‘map_{self.name}’

Parameters:

function (callable) – passed as modify_function to the map master
parameter_list (list) – passed as parameter_list to the map master

Returns:

newly created master job

Return type:

MapMaster

property master_id: int#

Get job id of the master job - a meta job which groups a series of jobs, which are executed either in parallel or in serial.

Returns:: master id
Return type:: int

move_to(project: ProjectHDFio) → None#

Move the content of the job including the HDF5 file to a new location

Parameters:: project (ProjectHDFio) – project to move the job to

property name: str#

Get name of the job, which has to be unique within the project

Returns:: job name
Return type:: str

next(job_name=None, job_type=None)#

Restart a new job created from an existing Lammps calculation. :param project: Project instance at which the new job should be created :type project: pyiron_atomistics.project.Project instance :param job_name: Job name :type job_name: str :param job_type: Job type. If not specified a Lammps job type is assumed :type job_type: str

Returns:: New job
Return type:: new_ham (lammps.lammps.Lammps instance)

property number_of_structures#

maximum iteration_step + 1 that can be passed to get_structure().

Type:: int

property parent_id: int#

Get job id of the predecessor job - the job which was executed before the current one in the current job series

Returns:: parent id
Return type:: int

property path: str#

Absolute path of the HDF5 group starting from the system root - combination of the absolute system path plus the absolute path inside the HDF5 file starting from the root group.

Returns:: absolute path
Return type:: str

property potential#

Execute view_potentials() or list_potentials() in order to see the pre-defined potential files

Returns:

property potential_list#

List of interatomic potentials suitable for the current atomic structure.

use self.potentials_view() to get more details.

Returns:: potential names
Return type:: list

property potential_view#

List all interatomic potentials for the current atomistic sturcture including all potential parameters.

To quickly get only the names of the potentials you can use: self.potentials_list()

Returns:: Dataframe including all potential parameters.
Return type:: pandas.Dataframe

property project: pyiron_base.project.generic.Project#

Project instance the jobs is located in

Returns:: project the job is located in
Return type:: Project

property project_hdf5: ProjectHDFio#

Get the ProjectHDFio instance which points to the HDF5 file the job is stored in

Returns:: HDF5 project
Return type:: ProjectHDFio

property queue_id: int#

Get the queue ID, the ID returned from the queuing system - it is most likely not the same as the job ID.

Returns:: queue ID
Return type:: int

read_restart_file(filename='restart.out')#

Parameters:: filename

Returns:

refresh_job_status() → None#: Refresh job status by updating the job status with the status from the database if a job ID is available.

relocate_hdf5(h5_path: str | None = None)#: Relocate the hdf file. This function is needed when the child job is spawned by a parent job (cf. pyiron_base.jobs.master.generic)

remap_indices(lammps_indices)#

Give the Lammps-dumped indices, re-maps these back onto the structure’s indices to preserve the species.

The issue is that for an N-element potential, Lammps dumps the chemical index from 1 to N based on the order that these species are written in the Lammps input file. But the indices for a given structure are based on the order in which chemical species were added to that structure, and run from 0 up to the number of species currently in that structure. Therefore we need to be a little careful with mapping.

Parameters:: indices (numpy.ndarray/list) – The Lammps-dumped integers.
Returns:: Those integers mapped onto the structure.
Return type:: numpy.ndarray

remove(_protect_childs: bool = True) → None#

Remove the job - this removes the HDF5 file, all data stored in the HDF5 file an the corresponding database entry.

Parameters:: _protect_childs (bool) – [True/False] by default child jobs can not be deleted, to maintain the consistency - default=True

remove_and_reset_id(_protect_childs: bool = True) → None#

Remove the job and reset its ID.

Parameters:: _protect_childs (bool) – Flag indicating whether to protect child jobs (default is True).
Returns:: None

remove_child() → None#: internal function to remove command that removes also child jobs. Do never use this command, since it will destroy the integrity of your project.

rename(new_job_name: str) → None#

Rename the job - by changing the job name

Parameters:: new_job_name (str) – new job name

reset_job_id(job_id: int | None = None) → None#: Reset the job id sets the job_id to None in the GenericJob as well as all connected modules like JobStatus.

restart(job_name=None, job_type=None)#

Restart a new job created from an existing Lammps calculation. :param project: Project instance at which the new job should be created :type project: pyiron_atomistics.project.Project instance :param job_name: Job name :type job_name: str :param job_type: Job type. If not specified a Lammps job type is assumed :type job_type: str

Returns:: New job
Return type:: lammps.lammps.Lammps instance

property restart_file_dict: dict#: A dictionary of the new name of the copied restart files

property restart_file_list: list#

Get the list of files which are used to restart the calculation from these files.

Returns:: list of files
Return type:: list

run(delete_existing_job: bool = False, repair: bool = False, debug: bool = False, run_mode: str | None = None, run_again: bool = False) → None#

This is the main run function, depending on the job status [‘initialized’, ‘created’, ‘submitted’, ‘running’, ‘collect’,’finished’, ‘refresh’, ‘suspended’] the corresponding run mode is chosen.

Parameters:

delete_existing_job (bool) – Delete the existing job and run the simulation again.
repair (bool) – Set the job status to created and run the simulation again.
debug (bool) – Debug Mode - defines the log level of the subprocess the job is executed in.
run_mode (str) – [‘modal’, ‘non_modal’, ‘queue’, ‘manual’] overwrites self.server.run_mode
run_again (bool) – Same as delete_existing_job (deprecated)

run_if_interactive()#: For jobs which executables are available as Python library, those can also be executed with a library call instead of calling an external executable. This is usually faster than a single core python job.

run_if_interactive_non_modal()#: For jobs which executables are available as Python library, those can also be executed with a library call instead of calling an external executable. This is usually faster than a single core python job.

run_if_modal() → None#: The run if modal function is called by run to execute the simulation, while waiting for the output. For this we use subprocess.check_output()

run_if_refresh() → None#: Internal helper function the run if refresh function is called when the job status is ‘refresh’. If the job was suspended previously, the job is going to be started again, to be continued.

run_if_scheduler() → None | int#: The run if queue function is called by run if the user decides to submit the job to and queing system. The job is submitted to the queuing system using subprocess.Popen() :returns: Returns the queue ID for the job. :rtype: int

run_static() → None | int#: The run static function is called by run to execute the simulation.

run_time_to_db() → None#: Internal helper function to store the run_time in the database

save() → None#

Save the object, by writing the content to the HDF5 file and storing an entry in the database.

Returns:: Job ID stored in the database
Return type:: (int)

save_output(output_dict: dict | None = None, shell_output: str | None = None)#

Store output of the calculate function in the HDF5 file.

Parameters:

output_dict (dict) – hierarchical output dictionary to be stored in the HDF5 file.
shell_output (str) – shell output from calling the external executable to be stored in the HDF5 file.

self_archive() → None#: Compress HDF5 file of the job object to tar-archive

self_unarchive() → None#: Decompress HDF5 file of the job object from tar-archive

property server: Server#

Get the server object to handle the execution environment for the job.

Returns:: server object
Return type:: Server

set_fix_external(function, n_call=1, n_apply=1, overload_internal_fix_external=False)#

* Expert feature *#

Set fix_external function that modifies forces.

param function:: User-defined function that returns forces (see below)
type function:: function
param n_call:: Make fix_external every n_call steps (default: 1)
type n_call:: int
param n_apply:: Apply fix_external forces every n_apply steps (default: 1)
type n_apply:: int
param overload_internal_fix_external:: Whether to overload internal fix_external (see below).
type overload_internal_fix_external:: bool

function must have the following form:

``` def function(positions, ntimestep, nlocal):

your_evaluation return forces

``` where positions is the positions of all atoms on the local processor, ntimestep is the current timestep and nlocal is the number of atoms on the current processor. forces must be of the shape (n_atoms, 3). The total translational force will be eliminated inside pyiron. The fix then adds these forces to each atom in the box, once every n_apply steps, similar to the way the fix addforce command works. Note that if n_call > n_apply, the force values produced by one callback will persist, and be used multiple times to update atom forces.

Example: Add random forces

``` from pyiron import Project

def random_forces(x, *args):: return 0.1 * np.random.randn(*x.shape)

pr = Project(‘RANDOM’) lmp = pr.create.job.Lammps(‘random_forces’) lmp.structure = your_structure lmp.potential = your_potential lmp.interactive_open() lmp.set_fix_external(random_forces) lmp.calc_md() lmp.run() lmp.interactive_close() ```

* Super-expert feature: `overload_internal_fix_external = True` *

If overload_internal_fix_external is set to True, then function must have the following form:

``` def function(ptr, timestep, nlocal, ids, x, fexternal):

your_evaluation

```

with the following arguemnts:

ptr: pointer provided by and simply passed back to external driver
timestep: current LAMMPS timestep
nlocal: # of atoms on this processor
ids: list of atom IDs on this processor
x: coordinates of atoms on this processor
fexternal: forces to add to atoms on this processor

Overloading the internal fix_external function will have the advantage that the code will not need to do expensive copying, BUT it is extremely error-prone. Make sure that the code works without overloading the internal fix_external function first.

Note: Do NOT overwrite fexternal, because it points to the internal memory of LAMMPS and therefore overwriting it will erase its functionality. E.g. DO fexternal.fill(0) and NOT fexternal = np.zeros_like(x).

set_input_to_read_only()#: This function enforces read-only mode for the input classes, but it has to be implement in the individual classes.

set_potential(file_name)#

Parameters:: file_name

Returns:

show_hdf() → None#: Iterating over the HDF5 datastructure and generating a human readable graph.

signal_intercept(sig) → None#

Abort the job and log signal that caused it.

Expected to be called from pyiron_base.state.signal.catch_signals().

Parameters:: sig (int) – the signal that triggered the abort

property status: str#

Execution status of the job, can be one of the following [initialized, appended, created, submitted, running,: aborted, collect, suspended, refresh, busy, finished]

Returns:: status
Return type:: (str/pyiron_base.job.jobstatus.JobStatus)

store_structure()#

Create StructureContainer job with the initial structure of the job and sets that jobs parent_id from this job.

Returns:: job containing initial structure of this job
Return type:: StructureContainer

property structure#: Returns:

suspend() → None#: Suspend the job by storing the object and its state persistently in HDF5 file and exit it.

to_dict()#

Reduce the object to a dictionary.

Returns:: serialized state of this object
Return type:: dict

to_hdf(hdf: pyiron_base.storage.hdfio.ProjectHDFio | None = None, group_name: str | None = None)#

Store the InteractiveBase object in the HDF5 File

Parameters:

hdf (ProjectHDFio) – HDF5 group object - optional
group_name (str) – HDF5 subgroup name - optional

to_object(object_type: str | None = None, **qwargs) → pyiron_base.job.generic.GenericJob#

Load the full pyiron object from an HDF5 file

Parameters:

object_type – if the ‘TYPE’ node is not available in the HDF5 file a manual object type can be set - optional
**qwargs – optional parameters [‘job_name’, ‘project’] - to specify the location of the HDF5 path

Returns:

pyiron object

Return type:

GenericJob

trajectory(stride=1, center_of_mass=False, atom_indices=None, snapshot_indices=None, overwrite_positions=None, overwrite_cells=None)#

Returns a Trajectory instance containing the necessary information to describe the evolution of the atomic structure during the atomistic simulation.

Parameters:

stride (int) – The trajectories are generated with every ‘stride’ steps
center_of_mass (bool) – False (default) if the specified positions are w.r.t. the origin
atom_indices (list/ndarray) – The atom indices for which the trajectory should be generated
snapshot_indices (list/ndarray) – The snapshots for which the trajectory should be generated
overwrite_positions (list/ndarray) – List of positions that are meant to overwrite the existing trajectory. Useful to wrap coordinates for example
overwrite_cells (list/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

Returns:

Trajectory instance

Return type:

pyiron_atomistics.atomistics.job.atomistic.Trajectory

transfer_from_remote() → None#

Transfer the job from a remote location to the local machine.

This method transfers the job from a remote location to the local machine. It performs the following steps: 1. Retrieves the job from the remote location using the queue adapter. 2. Transfers the job file to the remote location, with the option to delete the file on the remote location after transfer. 3. Updates the project database if it is disabled, otherwise updates the file table in the database with the job information.

Parameters:: None
Returns:: None

transform_structures(modify) → TransformStructure#

Return a modified object by applying a function to each object lazily.

Parameters:: modify (function) – applied to each structure, has to return the modified structure
Returns:: a container with the modified structures
Return type:: TransformStructure

property units#

Type of LAMMPS units used in the calculations. Can be either of ‘metal’, ‘real’, ‘si’, ‘cgs’, and ‘lj’

Returns:: Type of LAMMPS unit
Return type:: str

update_master(force_update: bool = False) → None#

After a job is finished it checks whether it is linked to any metajob - meaning the master ID is pointing to this jobs job ID. If this is the case and the master job is in status suspended - the child wakes up the master job, sets the status to refresh and execute run on the master job. During the execution the master job is set to status refresh. If another child calls update_master, while the master is in refresh the status of the master is set to busy and if the master is in status busy at the end of the update_master process another update is triggered.

Parameters:: force_update (bool) – Whether to check run mode for updating master

validate_ready_to_run()#: Validating input parameters before LAMMPS run

property version: str#

Get the version of the hamiltonian, which is also the version of the executable unless a custom executable is used.

Returns:: version number
Return type:: str

view_potentials() → DataFrame#

List all interatomic potentials for the current atomistic structure including all potential parameters.

To quickly get only the names of the potentials you can use: self.list_potentials()

Returns:: Dataframe including all potential parameters.
Return type:: pandas.Dataframe

view_structure(snapshot=-1, spacefill=True, show_cell=True)#

Parameters:

snapshot (int) – Snapshot of the trajectory one wants
spacefill (bool)
show_cell (bool)

Returns:

nglview IPython widget

Return type:

view

property working_directory: str#

Get the working directory of the job is executed in - outside the HDF5 file. The working directory equals the path but it is represented by the filesystem:

/absolute/path/to/the/file.h5/path/inside/the/hdf5/file

becomes:: /absolute/path/to/the/file_hdf5/path/inside/the/hdf5/file

Returns:: absolute path to the working directory
Return type:: str

write_input() → None#: Call routines that generate the code specific input files Returns:

write_restart_file(filename='restart.out')#

Parameters:: filename

Returns:

write_traj(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.

Parameters:

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

pyiron_atomistics.lammps.lammps.Lammps

Contents

pyiron_atomistics.lammps.lammps.Lammps#

* Expert feature *#