atomate.lammps.firetasks package

Submodules

atomate.lammps.firetasks.glue_tasks module

class atomate.lammps.firetasks.glue_tasks.CopyPackmolOutputs(*args, **kwargs)

Bases: atomate.common.firetasks.glue_tasks.CopyFiles

Copy files from a previous run directory to the current directory. Note: must specify either “calc_loc” or “calc_dir” to indicate the directory

containing the files to copy.

Optional params:
calc_loc (str OR bool): if True will set most recent calc_loc. If str

search for the most recent calc_loc with the matching name.

calc_dir (str): path to dir that contains VASP output files. filesystem (str): remote filesystem. e.g. username@host exclude_files (list): list fo filenames to be excluded when copying.

NOte: by default nothing is excluded.

optional_params = ['calc_loc', 'calc_dir', 'filesystem', 'exclude_files']
run_task(fw_spec)

This method gets called when the Firetask is run. It can take in a Firework spec, perform some task using that data, and then return an output in the form of a FWAction.

Args:
fw_spec (dict): A Firework spec. This comes from the master spec.

In addition, this spec contains a special “_fw_env” key that contains the env settings of the FWorker calling this method. This provides for abstracting out certain commands or settings. For example, “foo” may be named “foo1” in resource 1 and “foo2” in resource 2. The FWorker env can specify { “foo”: “foo1”}, which maps an abstract variable “foo” to the relevant “foo1” or “foo2”. You can then write a task that uses fw_spec[“_fw_env”][“foo”] that will work across all these multiple resources.

Returns:

(FWAction)

atomate.lammps.firetasks.parse_outputs module

This module defines firetasks for parsing and processing the LAMMPS outputfiles to extract useful information such as the summary of transport properties and insert them into the database.

class atomate.lammps.firetasks.parse_outputs.LammpsToDB(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Enter a LAMMPS calculation into the database.

required_params:

input_filename (str)

optional_params:
calc_dir (str): path to dir (on current filesystem) that contains LAMMPS

output files. Default: use current working directory.

calc_loc (str OR bool): if True will set most recent calc_loc. If str

search for the most recent calc_loc with the matching name

db_file (str): path to file containing the database credentials.

Supports env_chk. Default: write data to JSON file.

fw_spec_field: data_filename: log_filename: dump_filenames: diffusion_params additional_fields:

optional_params = ['calc_dir', 'calc_loc', 'db_file', 'fw_spec_field', 'data_filename', 'log_filename', 'dump_filenames', 'diffusion_params', 'additional_fields']
required_params = ['input_filename']
run_task(fw_spec)

This method gets called when the Firetask is run. It can take in a Firework spec, perform some task using that data, and then return an output in the form of a FWAction.

Args:
fw_spec (dict): A Firework spec. This comes from the master spec.

In addition, this spec contains a special “_fw_env” key that contains the env settings of the FWorker calling this method. This provides for abstracting out certain commands or settings. For example, “foo” may be named “foo1” in resource 1 and “foo2” in resource 2. The FWorker env can specify { “foo”: “foo1”}, which maps an abstract variable “foo” to the relevant “foo1” or “foo2”. You can then write a task that uses fw_spec[“_fw_env”][“foo”] that will work across all these multiple resources.

Returns:

(FWAction)

atomate.lammps.firetasks.run_calc module

This module defines firetasks for running lammps

class atomate.lammps.firetasks.run_calc.RunLammpsDirect(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Run LAMMPS directly (no custodian).

Required params:
lammsps_cmd (str): lammps command to run sans the input file name.

e.g. ‘mpirun -n 4 lmp_mpi’

required_params = ['lammps_cmd', 'input_filename']
run_task(fw_spec)

This method gets called when the Firetask is run. It can take in a Firework spec, perform some task using that data, and then return an output in the form of a FWAction.

Args:
fw_spec (dict): A Firework spec. This comes from the master spec.

In addition, this spec contains a special “_fw_env” key that contains the env settings of the FWorker calling this method. This provides for abstracting out certain commands or settings. For example, “foo” may be named “foo1” in resource 1 and “foo2” in resource 2. The FWorker env can specify { “foo”: “foo1”}, which maps an abstract variable “foo” to the relevant “foo1” or “foo2”. You can then write a task that uses fw_spec[“_fw_env”][“foo”] that will work across all these multiple resources.

Returns:

(FWAction)

class atomate.lammps.firetasks.run_calc.RunLammpsFake(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Pretend run i.e just copy files from existing run dir.

Required params:

ref_dir (str): path to the reference dir

required_params = ['ref_dir']
run_task(fw_spec)

This method gets called when the Firetask is run. It can take in a Firework spec, perform some task using that data, and then return an output in the form of a FWAction.

Args:
fw_spec (dict): A Firework spec. This comes from the master spec.

In addition, this spec contains a special “_fw_env” key that contains the env settings of the FWorker calling this method. This provides for abstracting out certain commands or settings. For example, “foo” may be named “foo1” in resource 1 and “foo2” in resource 2. The FWorker env can specify { “foo”: “foo1”}, which maps an abstract variable “foo” to the relevant “foo1” or “foo2”. You can then write a task that uses fw_spec[“_fw_env”][“foo”] that will work across all these multiple resources.

Returns:

(FWAction)

class atomate.lammps.firetasks.run_calc.RunPackmol(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Run packmol.

Required params:

molecules (list): list of constituent molecules(Molecule objects) packing_config (list): list of dict config settings for each molecule in the

molecules list. eg: config settings for a single moelcule [{“number”: 1, “inside box”:[0,0,0,100,100,100]}]

Optional params:

tolerance (float): packmol tolerance filetype (string): input/output structure file type control_params (dict): packmol control parameters dictionary. Basically all parameters other

than structure/atoms

output_file (str): output file name. The extension will be adjusted according to the filetype copy_to_current_on_exit (bool): whether or not to copy the packed molecule output file to

the current directory.

site_property (str): the specified site property will be restored for the final Molecule object.

optional_params = ['tolerance', 'filetype', 'control_params', 'output_file', 'copy_to_current_on_exit', 'site_property']
required_params = ['molecules', 'packing_config', 'packmol_cmd']
run_task(fw_spec)

This method gets called when the Firetask is run. It can take in a Firework spec, perform some task using that data, and then return an output in the form of a FWAction.

Args:
fw_spec (dict): A Firework spec. This comes from the master spec.

In addition, this spec contains a special “_fw_env” key that contains the env settings of the FWorker calling this method. This provides for abstracting out certain commands or settings. For example, “foo” may be named “foo1” in resource 1 and “foo2” in resource 2. The FWorker env can specify { “foo”: “foo1”}, which maps an abstract variable “foo” to the relevant “foo1” or “foo2”. You can then write a task that uses fw_spec[“_fw_env”][“foo”] that will work across all these multiple resources.

Returns:

(FWAction)

atomate.lammps.firetasks.write_inputs module

This module defines firetasks for writing LAMMPS input files (data file and the control parameters file)

class atomate.lammps.firetasks.write_inputs.WriteInputFromForceFieldAndTopology(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

optional_params = ['data_filename', 'user_settings', 'ff_site_property']
required_params = ['input_file', 'final_molecule', 'constituent_molecules', 'mols_number', 'box_size', 'forcefield', 'topologies', 'input_filename']
run_task(fw_spec)

This method gets called when the Firetask is run. It can take in a Firework spec, perform some task using that data, and then return an output in the form of a FWAction.

Args:
fw_spec (dict): A Firework spec. This comes from the master spec.

In addition, this spec contains a special “_fw_env” key that contains the env settings of the FWorker calling this method. This provides for abstracting out certain commands or settings. For example, “foo” may be named “foo1” in resource 1 and “foo2” in resource 2. The FWorker env can specify { “foo”: “foo1”}, which maps an abstract variable “foo” to the relevant “foo1” or “foo2”. You can then write a task that uses fw_spec[“_fw_env”][“foo”] that will work across all these multiple resources.

Returns:

(FWAction)

class atomate.lammps.firetasks.write_inputs.WriteInputFromIOSet(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Writes LAMMPS Input files(data file and the control parameters file) from DictLammpsInput.

required_params:

lammps_input_set (LammpsInputSet) input_file (string): name of the file to which the input params will be written

optional_params:

data_filename (string): if specified the data file will be renamed

optional_params = ['data_filename']
required_params = ['lammps_input_set', 'input_filename']
run_task(fw_spec)

This method gets called when the Firetask is run. It can take in a Firework spec, perform some task using that data, and then return an output in the form of a FWAction.

Args:
fw_spec (dict): A Firework spec. This comes from the master spec.

In addition, this spec contains a special “_fw_env” key that contains the env settings of the FWorker calling this method. This provides for abstracting out certain commands or settings. For example, “foo” may be named “foo1” in resource 1 and “foo2” in resource 2. The FWorker env can specify { “foo”: “foo1”}, which maps an abstract variable “foo” to the relevant “foo1” or “foo2”. You can then write a task that uses fw_spec[“_fw_env”][“foo”] that will work across all these multiple resources.

Returns:

(FWAction)

Module contents