atomate.qchem.firetasks package

Submodules

atomate.qchem.firetasks.geo_transformations module

class atomate.qchem.firetasks.geo_transformations.RotateTorsion(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Writes QChem Input files from input sets. A dictionary is passed to WriteInputFromIOSet where parameters are given as keys in the dictionary.

required_params:
atom_indexes (list): This should be a list of the pymatgen molecule indexes of the four atoms in torsion angle to be rotated angle (float): This is the desired torsion angle in degrees (the value should be between -180 and 180)
optional_params:
molecule (Molecule): Specify a pymatgen molecule to be rotated. A molecule is optional because molecules can be inherited from previous fireworks
optional_params = ['molecule']
required_params = ['atom_indexes', 'angle']
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.qchem.firetasks.parse_outputs module

class atomate.qchem.firetasks.parse_outputs.QChemToDb(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Enter a QChem run into the database. Uses current directory unless you specify calc_dir or calc_loc.

Optional params:
calc_dir (str): path to dir (on current filesystem) that contains QChem
input and 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

input_file (str): name of the QChem input file output_file (str): name of the QChem output file additional_fields (dict): dict of additional fields to add db_file (str): path to file containing the database credentials.

Supports env_chk. Default: write data to JSON file.
fw_spec_field (str): if set, will update the task doc with the contents
of this key in the fw_spec.
multirun (bool): Whether the job to parse includes multiple
calculations in one input / output pair.
optional_params = ['calc_dir', 'calc_loc', 'input_file', 'output_file', 'additional_fields', 'db_file', 'fw_spec_field', 'multirun']
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.qchem.firetasks.run_calc module

class atomate.qchem.firetasks.run_calc.RunNoQChem(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Do NOT run QChem. Do nothing.

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.qchem.firetasks.run_calc.RunQChemCustodian(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Run QChem using custodian “on rails”, i.e. in a simple way that supports most common options.

Required params:
qchem_cmd (str): the name of the full executable for running QChem. Note that this is
explicitly different from qchem_cmd in RunQChemDirect because it does not include any flags and should only be the call to the executable. Supports env_chk.
Optional params:

multimode (str): Parallelization scheme, either openmp or mpi. input_file (str): Name of the QChem input file. output_file (str): Name of the QChem output file. max_cores (int): Maximum number of cores to parallelize over. Defaults to 32. qclog_file (str): Name of the file to redirect the standard output to. None means

not to record the standard output. Defaults to None.

suffix (str): String to append to the file in postprocess. scratch_dir (str): QCSCRATCH directory. Defaults to “/dev/shm/qcscratch/”. save_scratch (bool): Whether to save scratch directory contents. Defaults to False. save_name (str): Name of the saved scratch directory. Defaults to “default_save_name”. max_errors (int): Maximum # of errors to fix before giving up (default=5) job_type (str): Choose from “normal” (default) and “opt_with_frequency_flattener” handler_group (str): Group of handlers to use. See handler_groups dict in the code

for the groups and complete list of handlers in each group.

gzip_output (bool): gzip output (default=T)

* Just for opt_with_frequency_flattener * max_iterations (int): Number of perturbation -> optimization -> frequency iterations

to perform. Defaults to 10.
max_molecule_perturb_scale (float): The maximum scaled perturbation that can be
applied to the molecule. Defaults to 0.3.
reversed_direction (bool): Whether to reverse the direction of the vibrational
frequency vectors. Defaults to False.
optional_params = ['multimode', 'input_file', 'output_file', 'max_cores', 'qclog_file', 'suffix', 'scratch_dir', 'save_scratch', 'save_name', 'max_errors', 'max_iterations', 'max_molecule_perturb_scale', 'reversed_direction', 'job_type', 'handler_group', 'gzipped_output']
required_params = ['qchem_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)
class atomate.qchem.firetasks.run_calc.RunQChemDirect(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Execute a command directly (no custodian).

Required params:
qchem_cmd (str): The name of the full command line call to run. This should include any
flags for parallelization, saving scratch, etc. Supports env_chk.
Optional params:
scratch_dir (str): Path to the scratch directory. Defaults to “/dev/shm/qcscratch/”.
optional_params = ['scratch_dir']
required_params = ['qchem_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)
class atomate.qchem.firetasks.run_calc.RunQChemFake(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

QChem Emulator

Required params:
ref_dir (string): Path to reference qchem run directory with input file in the folder
named “mol.qin” and output file in the folder named “mol.qout”.
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)

atomate.qchem.firetasks.write_inputs module

class atomate.qchem.firetasks.write_inputs.WriteCustomInput(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Writes QChem Input files from custom input sets. This firetask gives the maximum flexibility when trying to define custom input parameters.

required_params:
qchem_input_custom (dict): Define custom input parameters to generate a qchem input file. This should be a dictionary of dictionaries (i.e. {{“rem”: {“method”: “b3lyp”, basis”: “6-31*G++”, …} Each QChem section should be a key with its own dictionary as the value. For more details on how the input should be structured look at pymatgen.io.qchem_io.inputs * *
optional_params:
molecule (Molecule): input_file (str): Name of the QChem input file. Defaults to mol.qin write_to_dir (str): Path of the directory where the QChem input file will be written, the default is to write to the current working directory
optional_params = ['molecule', 'opt', 'pcm', 'solvent', 'input_file', 'write_to_dir']
required_params = ['rem']
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.qchem.firetasks.write_inputs.WriteInput(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Writes QChem input file from QCInput object.

required_params:
qc_input (QCInput): QCInput object
optional_params:
input_file (str): Name of the QChem input file. Defaults to mol.qin write_to_dir (str): Path of the directory where the QChem input file will be written, the default is to write to the current working directory
optional_params = ['input_file', 'write_to_dir']
required_params = ['qc_input']
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.qchem.firetasks.write_inputs.WriteInputFromIOSet(*args, **kwargs)

Bases: fireworks.core.firework.FiretaskBase

Writes QChem Input files from input sets. A dictionary is passed to WriteInputFromIOSet where parameters are given as keys in the dictionary.

required_params:
qc_input_set (QChemDictSet or str): Either a QChemDictSet object or a string name for the QChem input set (e.g., “OptSet”). * Note that if the molecule is to be inherited through fw_spec qc_input_set must be a string name for the QChem input set. *
optional_params:
qchem_input_params (dict): When using a string name for QChem input set, use this as a dict to specify kwargs for instantiating the input set parameters. For example, if you want to change the DFT_rung, you should provide: {“DFT_rung”: …}. This setting is ignored if you provide the full object representation of a QChemDictSet rather than a String. molecule (Molecule): input_file (str): Name of the QChem input file. Defaults to mol.qin write_to_dir (str): Path of the directory where the QChem input file will be written, the default is to write to the current working directory
optional_params = ['molecule', 'qchem_input_params', 'input_file', 'write_to_dir']
required_params = ['qchem_input_set']
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