atomate.feff.firetasks package — atomate 0.9.2 documentation

# atomate.feff.firetasks package

## Subpackages

- atomate.feff.firetasks.tests package
  - Submodules
  - atomate.feff.firetasks.tests.test_tasks module
  - Module contents

## Submodules

## atomate.feff.firetasks.glue_tasks module

class `atomate.feff.firetasks.glue_tasks.` `CopyFeffOutputs`(*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.

  `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.feff.firetasks.parse_outputs module

class `atomate.feff.firetasks.parse_outputs.` `AddPathsToFilepadTask`(*args, **kwargs)

  Bases: `fireworks.core.firework.FiretaskBase`

  Insert the scattering amplitude outputs(all feffNNNN.dat files) to gridfs using filepad.

  Optional_params:

    labels (list): list of labels to tag the inserted files. Useful for querying later. filepad_file (str): path to the filepad connection settings file. compress (bool): wether or not to compress the file contents before insertion. metadata (dict): metadata.

  `optional_params` = ['labels', 'filepad_file', 'compress', 'metadata']
  `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.feff.firetasks.parse_outputs.` `SpectrumToDbTask`(*args, **kwargs)

  Bases: `fireworks.core.firework.FiretaskBase`

  Parse the output of absorption/core-loss spectrum calculations(xmu.dat, eels.dat) and insert it into the database.

  Required_params:

    absorbing_atom (str): absorbing atom symbol structure (Structure): input structure spectrum_type (str): XANES, EXAFS, ELNES, EXELFS output_file (str): the output file name. xmu.dat or eels.dat

  Optional_params:

    input_file (str): path to the feff input file. calc_dir (str): path to dir (on current filesystem) that contains FEFF 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 the db file. edge (str): absorption edge metadata (dict): meta data

  `optional_params` = ['input_file', 'calc_dir', 'calc_loc', 'db_file', 'edge', 'metadata']
  `required_params` = ['absorbing_atom', 'structure', 'spectrum_type', 'output_file']
  `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.feff.firetasks.run_calc module

class `atomate.feff.firetasks.run_calc.` `RunFeffDirect`(*args, **kwargs)

  Bases: `fireworks.core.firework.FiretaskBase`

  Run FEFF.

  Required params:

    feff_cmd (str): the name of the full executable for running FEFF (supports env_chk)

  `required_params` = ['feff_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.feff.firetasks.write_inputs module

class `atomate.feff.firetasks.write_inputs.` `WriteEXAFSPaths`(*args, **kwargs)

  Bases: `fireworks.core.firework.FiretaskBase`

  Write the scattering paths to paths.dat file.

  Required_params:

    feff_input_set: (FeffDictSet subclass) paths (list): list of paths. A path = list of site indices.

  Optional_params:

    degeneracies (list): list of path degeneracies.

  `optional_params` = ['degeneracies']
  `required_params` = ['feff_input_set', 'paths']
  `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.feff.firetasks.write_inputs.` `WriteFeffFromIOSet`(*args, **kwargs)

  Bases: `fireworks.core.firework.FiretaskBase`

  Generate FEFF input (feff.inp) from the given InputSet object or InputSet name

  Required_params:

    absorbing_atom (str): absorbing atom symbol structure (Structure): input structure feff_input_set (str or FeffDictSet subclass): The inputset for setting params. If string

    > then either the entire path to the class or the spectrum type must be provided e.g. “pymatgen.io.feff.sets.MPXANESSet” or “XANES”

  Optional_params:

    radius (float): cluster radius in angstroms other_params (dict): **kwargs to pass into the desired InputSet if using str feff_input_set

  `optional_params` = ['radius', 'other_params']
  `required_params` = ['absorbing_atom', 'structure', 'feff_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)

`atomate.feff.firetasks.write_inputs.` `get_feff_input_set_obj`(fis, *args, **kwargs)

  returns feff input set object.

  Args:
    fis (str or FeffDictSet subclass): The inputset for setting params. If string then

      the entire path to the class or the spectrum type must be provided e.g. “pymatgen.io.feff.sets.MPXANESSet” or “XANES”

    args (tuple): feff input set args kwargs (dict): feff input set kwargs

  Returns:

    FeffDictSet object

## Module contents