arc.scheduler

A module for scheduling jobs Includes spawning, terminating, checking, and troubleshooting various jobs

class arc.scheduler.Scheduler(project: str, ess_settings: dict, species_list: list, project_directory: str, composite_method: Optional[arc.level.Level] = None, conformer_level: Optional[arc.level.Level] = None, opt_level: Optional[arc.level.Level] = None, freq_level: Optional[arc.level.Level] = None, sp_level: Optional[arc.level.Level] = None, scan_level: Optional[arc.level.Level] = None, ts_guess_level: Optional[arc.level.Level] = None, irc_level: Optional[arc.level.Level] = None, orbitals_level: Optional[arc.level.Level] = None, adaptive_levels: Optional[dict] = None, rmg_database: Optional = None, job_types: Optional[dict] = None, rxn_list: Optional[list] = None, bath_gas: Optional[str] = None, restart_dict: Optional[dict] = None, max_job_time: Optional[float] = None, allow_nonisomorphic_2d: Optional[bool] = False, memory: Optional[float] = None, testing: Optional[bool] = False, dont_gen_confs: Optional[list] = None, n_confs: Optional[int] = 10, e_confs: Optional[float] = 5, fine_only: Optional[bool] = False)[source]

ARC’s Scheduler class. Creates jobs, submits, checks status, troubleshoots. Each species in species_list has to have a unique label.

Dictionary structures:

job_dict = {label_1: {'conformers': {0: Job1,
                                     1: Job2, ...},  # TS guesses are considered `conformers` as well
                      'opt':        {job_name1: Job1,
                                     job_name2: Job2, ...},
                      'sp':         {job_name1: Job1,
                                     job_name2: Job2, ...},
                      'freq':       {job_name1: Job1,
                                     job_name2: Job2, ...},
                      'composite':  {job_name1: Job1,
                                     job_name2: Job2, ...},
                      'scan':       {job_name1: Job1,
                                     job_name2: Job2, ...},
                      <job_type>:   {job_name1: Job1,
                                     job_name2: Job2, ...},
                      ...
                      }
            label_2: {...},
            }

output = {label_1: {'job_types': {job_type1: <status1>,  # boolean
                                  job_type2: <status2>,
                                 },
                    'paths': {'geo': <path to geometry optimization output file>,
                              'freq': <path to freq output file>,
                              'sp': <path to sp output file>,
                              'composite': <path to composite output file>,
                              'irc': [list of two IRC paths],
                             },
                    'conformers': <comments>,
                    'isomorphism': <comments>,
                    'convergence': <status>,  # Optional[bool]
                    'restart': <comments>,
                    'info': <comments>,
                    'warnings': <comments>,
                    'errors': <comments>,
                   },
         label_2: {...},
         }

Note

The rotor scan dicts are located under Species.rotors_dict

Parameters
  • project (str) – The project’s name. Used for naming the working directory.

  • ess_settings (dict) – A dictionary of available ESS and a corresponding server list.

  • species_list (list) – Contains input ARCSpecies objects (both wells and TSs).

  • rxn_list (list) – Contains input ARCReaction objects.

  • project_directory (str) – Folder path for the project: the input file path or ARC/Projects/project-name.

  • composite_method (str, optional) – A composite method to use.

  • conformer_level (Union[str, dict], optional) – The level of theory to use for conformer comparisons.

  • opt_level (Union[str, dict], optional) – The level of theory to use for geometry optimizations.

  • freq_level (Union[str, dict], optional) – The level of theory to use for frequency calculations.

  • sp_level (Union[str, dict], optional) – The level of theory to use for single point energy calculations.

  • scan_level (Union[str, dict], optional) – The level of theory to use for torsion scans.

  • ts_guess_level (Union[str, dict], optional) – The level of theory to use for TS guess comparisons.

  • irc_level (Union[str, dict], optional) – The level of theory to use for IRC calculations.

  • orbitals_level (Union[str, dict], optional) – The level of theory to use for calculating MOs (for plotting).

  • adaptive_levels (dict, optional) – A dictionary of levels of theory for ranges of the number of heavy atoms in the species. Keys are tuples of (min_num_atoms, max_num_atoms), values are dictionaries with job type tuples as keys and levels of theory as values. ‘inf’ is accepted an max_num_atoms rmg_database (RMGDatabase, optional): The RMG database object.

  • job_types (dict, optional) – A dictionary of job types to execute. Keys are job types, values are boolean.

  • bath_gas (str, optional) – A bath gas. Currently used in OneDMin to calc L-J parameters. Allowed values are He, Ne, Ar, Kr, H2, N2, O2.

  • restart_dict (dict, optional) – A restart dictionary parsed from a YAML restart file.

  • max_job_time (float, optional) – The maximal allowed job time on the server in hours (can be fractional).

  • allow_nonisomorphic_2d (bool, optional) – Whether to optimize species even if they do not have a 3D conformer that is isomorphic to the 2D graph representation.

  • memory (float, optional) – The total allocated job memory in GB (14 by default).

  • testing (bool, optional) – Used for internal ARC testing (generating the object w/o executing it).

  • dont_gen_confs (list, optional) – A list of species labels for which conformer jobs were loaded from a restart file, or user-requested. Additional conformer generation should be avoided.

  • n_confs (int, optional) – The number of lowest force field conformers to consider.

  • e_confs (float, optional) – The energy threshold in kJ/mol above the lowest energy conformer below which force field conformers are considered.

  • fine_only (bool) – If True ARC will not run optimization jobs without fine=True

project

The project’s name. Used for naming the working directory.

Type

str

servers

A list of servers used for the present project.

Type

list

species_list

Contains input ARCSpecies objects (both species and TSs).

Type

list

species_dict

Keys are labels, values are ARCSpecies objects.

Type

dict

rxn_list

Contains input ARCReaction objects.

Type

list

unique_species_labels

A list of species labels (checked for duplicates).

Type

list

job_dict

A dictionary of all scheduled jobs. Keys are species / TS labels, values are dictionaries where keys are job names (corresponding to ‘running_jobs’ if job is running) and values are the Job objects.

Type

dict

running_jobs

A dictionary of currently running jobs (a subset of job_dict). Keys are species/TS label, values are lists of job names (e.g. ‘conformer3’, ‘opt_a123’).

Type

dict

servers_jobs_ids

A list of relevant job IDs currently running on the server.

Type

list

output

Output dictionary with status per job type and final QM file paths for all species.

Type

dict

ess_settings

A dictionary of available ESS and a corresponding server list.

Type

dict

restart_dict

A restart dictionary parsed from a YAML restart file.

Type

dict

project_directory

Folder path for the project: the input file path or ARC/Projects/project-name.

Type

str

save_restart

Whether to start saving a restart file. True only after all species are loaded (otherwise saves a partial file and may cause loss of information).

Type

bool

restart_path

Path to the restart.yml file to be saved.

Type

str

max_job_time

The maximal allowed job time on the server in hours (can be fractional).

Type

float

testing

Used for internal ARC testing (generating the object w/o executing it).

Type

bool

rmg_database

The RMG database object.

Type

RMGDatabase

allow_nonisomorphic_2d

Whether to optimize species even if they do not have a 3D conformer that is isomorphic to the 2D graph representation.

Type

bool

dont_gen_confs

A list of species labels for which conformer jobs were loaded from a restart file, or user-requested. Additional conformer generation should be avoided for them.

Type

list

memory

The total allocated job memory in GB (14 by default).

Type

float

n_confs

The number of lowest force field conformers to consider.

Type

int

e_confs

The energy threshold in kJ/mol above the lowest energy conformer below which force field conformers are considered.

Type

float

job_types

A dictionary of job types to execute. Keys are job types, values are boolean.

Type

dict

bath_gas

A bath gas. Currently used in OneDMin to calc L-J parameters. Allowed values are He, Ne, Ar, Kr, H2, N2, O2.

Type

str

composite_method

A composite method to use.

Type

str

conformer_level

The level of theory to use for conformer comparisons.

Type

dict

opt_level

The level of theory to use for geometry optimizations.

Type

dict

freq_level

The level of theory to use for frequency calculations.

Type

dict

sp_level

The level of theory to use for single point energy calculations.

Type

dict

scan_level

The level of theory to use for torsion scans.

Type

dict

ts_guess_level

The level of theory to use for TS guess comparisons.

Type

dict

irc_level

The level of theory to use for IRC calculations.

Type

dict

orbitals_level

The level of theory to use for calculating MOs (for plotting).

Type

dict

adaptive_levels

A dictionary of levels of theory for ranges of the number of heavy atoms in the species. Keys are tuples of (min_num_atoms, max_num_atoms), values are dictionaries with job type tuples as keys and levels of theory as values. ‘inf’ is accepted an max_num_atoms rmg_database (RMGDatabase, optional): The RMG database object.

Type

dict

fine_only

If True ARC will not run optimization jobs without fine=True

Type

bool

check_all_done(label)[source]

Check that we have all required data for the species/TS.

Parameters

label (str) – The species label.

check_directed_scan(label, pivots, scan, energies)[source]

Checks (QA) whether the directed scan is relatively “smooth”, and whether the optimized geometry indeed represents the minimum energy conformer. Recommends whether or not to use this rotor using the ‘successful_rotors’ and ‘unsuccessful_rotors’ attributes. This method differs from check_directed_scan_job(), since here we consider the entire scan.

Parameters
  • label (str) – The species label.

  • pivots (list) – The rotor pivots.

  • scan (list) – The four atoms defining the dihedral.

  • energies (list) – The rotor scan energies in kJ/mol.

check_directed_scan_job(label, job)[source]

Check that a directed scan job for a specific dihedral angle converged successfully, otherwise troubleshoot.

rotors_dict structure (attribute of ARCSpecies):

rotors_dict: {1: {'pivots': ``list``,
                  'top': ``list``,
                  'scan': ``list``,
                  'number_of_running_jobs': ``int``,
                  'success': ``bool``,
                  'invalidation_reason': ``str``,
                  'times_dihedral_set': ``int``,
                  'scan_path': <path to scan output file>,
                  'max_e': ``float``,  # in kJ/mol,
                  'symmetry': ``int``,
                  'dimensions': ``int``,
                  'original_dihedrals': ``list``,
                  'cont_indices': ``list``,
                  'directed_scan_type': ``str``,
                  'directed_scan': ``dict``,  # keys: tuples of dihedrals as strings,
                                              # values: dicts of energy, xyz, is_isomorphic, trsh
                 }
              2: {}, ...
             }
Parameters
  • label (str) – The species label.

  • job (Job) – The rotor scan job object.

check_freq_job(label, job)[source]

Check that a freq job converged successfully. Also checks (QA) that no imaginary frequencies were assigned for stable species, and that exactly one imaginary frequency was assigned for a TS.

Parameters
  • label (str) – The species label.

  • job (Job) – The frequency job object.

check_irc_job(label, job)[source]

Check an IRC job and perform post-job tasks.

Parameters
  • label (str) – The species label.

  • job (Job) – The single point job object.

check_negative_freq(label, job, vibfreqs)[source]

A helper function for determining the number of negative frequencies. Also logs appropriate errors. Returns True if the number of negative frequencies is as excepted, False otherwise.

Parameters
  • label (str) – The species label.

  • job (Job) – The optimization job object.

  • vibfreqs (list) – The vibrational frequencies.

check_scan_job(label: str, job: arc.job.job.Job) → None[source]

Check that a rotor scan job converged successfully. Also checks (QA) whether the scan is relatively “smooth”, and whether the optimized geometry indeed represents the minimum energy conformer. Recommends whether or not to use this rotor using the ‘successful_rotors’ and ‘unsuccessful_rotors’ attributes. rotors_dict structure (attribute of ARCSpecies):

rotors_dict: {1: {'pivots': ``list``,
                  'top': ``list``,
                  'scan': ``list``,
                  'number_of_running_jobs': ``int``,
                  'success': ``Optional[bool]``,
                  'invalidation_reason': ``str``,
                  'times_dihedral_set': ``int``,
                  'scan_path': <path to scan output file>,
                  'max_e': ``float``,  # in kJ/mol,
                  'symmetry': ``int``,
                  'trsh_methods': ``list``,
                  'dimensions': ``int``,
                  'original_dihedrals': ``list``,
                  'cont_indices': ``list``,
                  'directed_scan_type': ``str``,
                  'directed_scan': ``dict``,  # keys: tuples of dihedrals as strings,
                                              # values: dicts of energy, xyz, is_isomorphic, trsh
                 }
              2: {}, ...
             }
Parameters
  • label (str) – The species label.

  • job (Job) – The rotor scan job object.

check_sp_job(label, job)[source]

Check that a single point job converged successfully.

Parameters
  • label (str) – The species label.

  • job (Job) – The single point job object.

delete_all_species_jobs(label: str)[source]

Delete all jobs of a species/TS.

Parameters

label (str) – The species label.

determine_adaptive_level(original_level_of_theory: arc.level.Level, job_type: str, heavy_atoms: int)arc.level.Level[source]

Determine the level of theory to be used according to the job type and number of heavy atoms. self.adaptive_levels is a dictionary of levels of theory for ranges of the number of heavy atoms in the species. Keys are tuples of (min_num_atoms, max_num_atoms), values are dictionaries with job type tuples as keys and levels of theory as values. ‘inf’ is accepted an max_num_atoms.

Parameters
  • original_level_of_theory (Level) – The level of theory for non-sp/opt/freq job types.

  • job_type (str) – The job type for which the level of theory is determined.

  • heavy_atoms (int) – The number of heavy atoms in the species.

determine_most_likely_ts_conformer(label)[source]

Determine the most likely TS conformer. Save the resulting xyz as initial_xyz.

Parameters

label (str) – The TS species label.

determine_most_stable_conformer(label)[source]

Determine the most stable conformer for a species (which is not a TS). Also run an isomorphism check. Save the resulting xyz as initial_xyz.

Parameters

label (str) – The species label.

end_job(job, label, job_name)[source]

A helper function for checking job status, saving in csv file, and downloading output files.

Parameters
  • job (Job) – The job object.

  • label (str) – The species label.

  • job_name (str) – The job name from the running_jobs dict.

Returns

True if job terminated successfully on the server, False otherwise.

Return type

bool

get_servers_jobs_ids()[source]

Check status on all active servers, return a list of relevant running job IDs

initialize_output_dict(label: Optional[str] = None)[source]

Initialize self.output. Do not initialize keys that will contain paths (‘geo’, ‘freq’, ‘sp’, ‘composite’), their existence indicate the job was terminated for restarting purposes. If label is not None, will initialize for a specific species, otherwise will initialize for all species.

Parameters

label (str, optional) – A species label.

make_reaction_labels_info_file()[source]

A helper function for creating the reactions labels.info file

parse_composite_geo(label, job)[source]

Check that a ‘composite’ job converged successfully, and parse the geometry into final_xyz. Also checks (QA) that no imaginary frequencies were assigned for stable species, and that exactly one imaginary frequency was assigned for a TS. Returns True if the job converged successfully, False otherwise and troubleshoots.

Parameters
  • label (str) – The species label.

  • job (Job) – The composite job object.

parse_conformer(job, label, i)[source]

Parse E0 (kJ/mol) from the conformer opt output file. For species, save it in the Species.conformer_energies attribute. Fot TSs, save it in the TSGuess.energy attribute, and also parse the geometry.

Parameters
  • job (Job) – The conformer job object.

  • label (str) – The TS species label.

  • i (int) – The conformer index.

parse_opt_geo(label, job)[source]

Check that an ‘opt’ or ‘optfreq’ job converged successfully, and parse the geometry into final_xyz. If the job is ‘optfreq’, also checks (QA) that no imaginary frequencies were assigned for stable species, and that exactly one imaginary frequency was assigned for a TS. Returns True if the job (or both jobs) converged successfully, False otherwise and troubleshoots opt.

Parameters
  • label (str) – The species label.

  • job (Job) – The optimization job object.

post_sp_actions(label: str, sp_path: str, level: Optional[arc.level.Level] = None)[source]

Perform post-sp actions.

Parameters
  • label (str) – The species label.

  • sp_path (str) – The path to ‘output.out’ for the single point job.

  • level (Level, optional) – The level of theory used for the sp job.

process_conformers(label)[source]

Process the generated conformers and spawn DFT jobs at the conformer_level. If more than one conformer is available, they will be optimized at the DFT conformer_level.

Parameters

label (str) – The species label.

process_directed_scans(label, pivots)[source]

Process all directed rotors for a species and check the quality of the scan.

rotors_dict structure (attribute of ARCSpecies):

rotors_dict: {1: {'pivots': ``list``,
                  'top': ``list``,
                  'scan': ``list``,
                  'number_of_running_jobs': ``int``,
                  'success': ``Optional[bool]``,
                  'invalidation_reason': ``str``,
                  'times_dihedral_set': ``int``,
                  'scan_path': <path to scan output file>,
                  'max_e': ``float``,  # in kJ/mol,
                  'symmetry': ``int``,
                  'dimensions': ``int``,
                  'original_dihedrals': ``list``,
                  'cont_indices': ``list``,
                  'directed_scan_type': ``str``,
                  'directed_scan': ``dict``,  # keys: tuples of dihedrals as strings,
                                              # values: dicts of energy, xyz, is_isomorphic, trsh
                 }
              2: {}, ...
             }
Parameters
  • label (str) – The species label.

  • pivots (list) – The rotor pivots.

restore_running_jobs()[source]

Make Job objects for jobs which were running in the previous session. Important for the restart feature so long jobs won’t be ran twice.

run_composite_job(label)[source]

Spawn a composite job (e.g., CBS-QB3) using ‘final_xyz’ for species ot TS ‘label’.

Parameters

label (str) – The species label.

run_conformer_jobs(labels=None)[source]

Select the most stable conformer for each species using molecular dynamics (force fields) and subsequently spawning opt jobs at the conformer level of theory, usually a reasonable yet cheap DFT, e.g., b97d3/6-31+g(d,p). The resulting conformer is saved in a string format xyz in the Species initial_xyz attribute.

Parameters

labels (list) – Labels of specific species to run conformer jobs for. If None, conformer jobs will be spawned for all species corresponding to labels in self.unique_species_labels.

run_freq_job(label)[source]

Spawn a freq job using ‘final_xyz’ for species ot TS ‘label’. If this was originally a composite job, run an appropriate separate freq job outputting the Hessian.

Parameters

label (str) – The species label.

run_irc_job(label, irc_direction='forward')[source]

Spawn an IRC job.

Parameters
  • label (str) – The species label.

  • irc_direction (str) – The IRC job direction, either ‘forward’ or ‘reverse’.

run_job(label: str, level_of_theory: Union[arc.level.Level, dict, str], job_type: str, xyz: Optional[dict], fine: Optional[bool] = False, software: Optional[str] = None, shift: Optional[str] = '', trsh: Optional[str] = '', memory: Optional[int] = None, conformer: Optional[int] = - 1, ess_trsh_methods: Optional[list] = None, scan: Optional[list] = None, pivots: Optional[list] = None, occ: Optional[int] = None, scan_trsh: Optional[str] = '', scan_res: Optional[int] = None, max_job_time: Optional[int] = None, radius: Optional[float] = None, directed_scan_type: Optional[str] = None, directed_scans: Optional[list] = None, directed_dihedrals: Optional[list] = None, rotor_index: Optional[int] = None, cpu_cores: Optional[int] = None, irc_direction: Optional[str] = None)[source]

A helper function for running (all) jobs.

Parameters
  • label (str) – The species label.

  • xyz (dict) – The 3D coordinates for the species.

  • level_of_theory (Level) – The level of theory to use.

  • job_type (str) – The type of job to run.

  • fine (bool, optional) – Whether to run an optimization job with a fine grid. True to use fine.

  • software (str, optional) – An ESS software to use.

  • shift (str, optional) – A string representation alpha- and beta-spin orbitals shifts (molpro only).

  • trsh (str, optional) – A troubleshooting keyword to be used in input files.

  • memory (int, optional) – The total job allocated memory in GB.

  • conformer (int, optional) – Conformer number if optimizing conformers.

  • ess_trsh_methods (list, optional) – A list of troubleshooting methods already tried out for ESS convergence.

  • scan (list, optional) – A list representing atom labels for the dihedral scan (e.g., “2 1 3 5” as a string or [2, 1, 3, 5] as a list of integers).

  • pivots (list, optional) – The rotor scan pivots, if the job type is scan. Not used directly in these methods, but used to identify the rotor.

  • occ (int, optional) – The number of occupied orbitals (core + val) from a molpro CCSD sp calc.

  • scan_trsh (str, optional) – A troubleshooting method for rotor scans.

  • scan_res (int, optional) – The rotor scan resolution in degrees.

  • max_job_time (int, optional) – The maximal allowed job time on the server in hours.

  • radius (float, optional) – The species radius in Angstrom.

  • directed_scan_type (str, optional) – The type of the directed scan.

  • directed_scans (list, optional) – Entries are lists of four-atom dihedral scan indices to constrain.

  • directed_dihedrals (list, optional) – The dihedral angles of a directed scan job corresponding to directed_scans.

  • rotor_index (int, optional) – The 0-indexed rotor number (key) in the species.rotors_dict dictionary.

  • cpu_cores (int, optional) – The total number of cpu cores requested for a job.

  • irc_direction (str, optional) – The direction to run the IRC computation.

run_onedmin_job(label)[source]

Spawn a lennard-jones calculation using OneDMin.

Parameters

label (str) – The species label.

run_opt_job(label, fine=False)[source]

Spawn a geometry optimization job. The initial guess is taken from the initial_xyz attribute.

Parameters
  • label (str) – The species label.

  • fine (bool) – Whether or not a fine grid should be used during optimization

run_orbitals_job(label)[source]

Spawn orbitals job used for molecular orbital visualization. Currently supporting QChem for printing the orbitals, the output could be visualized using IQMol.

Parameters

label (str) – The species label.

run_scan_jobs(label)[source]

Spawn rotor scan jobs using ‘final_xyz’ for species (or TS).

Parameters

label (str) – The species label.

run_sp_job(label: str, level: Optional[arc.level.Level] = None)[source]

Spawn a single point job using ‘final_xyz’ for species ot TS ‘label’. If the method is MRCI, first spawn a simple CCSD job, and use orbital determination to run the MRCI job.

Parameters
  • label (str) – The species label.

  • level (Level) – An alternative level of theory to run at. If None, self.sp_level will be used.

run_ts_conformer_jobs(label)[source]

Spawn opt jobs at the ts_guesses level of theory for the TS guesses.

Parameters

label (str) – The TS species label.

save_restart_dict()[source]

Update the restart_dict and save the restart.yml file.

schedule_jobs()[source]

The main job scheduling block

spawn_directed_scan_jobs(label, rotor_index, xyz=None)[source]

Spawn directed scan jobs. Directed scan types could be one of the following: ‘brute_force_sp’, ‘brute_force_opt’, ‘cont_opt’, ‘brute_force_sp_diagonal’, ‘brute_force_opt_diagonal’, or ‘cont_opt_diagonal’. Here we treat cont and brute_force separately, and also consider the diagonal keyword. The differentiation between sp and opt is done in the Job module.

Parameters
  • label (str) – The species label.

  • rotor_index (int) – The 0-indexed rotor number (key) in the species.rotors_dict dictionary.

  • xyz (str, optional) – The 3D coordinates for a continuous directed scan.

Raises
  • InputError – If the species directed scan type has an unexpected value, or if xyz wasn’t given for a cont_opt job.

  • SchedulerError – If the rotor scan resolution as defined in settings.py is illegal.

spawn_post_opt_jobs(label: str, job_name: str)[source]

Spawn additional jobs after opt has converged.

Parameters
  • label (str) – The species label.

  • job_name (str) – The opt job name (used for differentiating between opt and optfreq jobs).

troubleshoot_conformer_isomorphism(label: str)[source]

Troubleshoot conformer optimization for a species that failed isomorphic test in determine_most_stable_conformer.

Parameters

label (str) – The species label.

troubleshoot_ess(label: str, job: arc.job.job.Job, level_of_theory: Union[arc.level.Level, dict, str], conformer: int = - 1)[source]

Troubleshoot issues related to the electronic structure software, such as conversion.

Parameters
  • label (str) – The species label.

  • job (Job) – The job object to troubleshoot.

  • level_of_theory (Level, dict, str) – The level of theory to use.

  • conformer (int, optional) – The conformer index.

troubleshoot_negative_freq(label, job)[source]

Troubleshooting cases where non-TS species have negative frequencies. Run newly generated conformers.

Parameters
  • label (str) – The species label.

  • job (Job) – The frequency job object.

troubleshoot_opt_jobs(label)[source]

We’re troubleshooting for opt jobs. First check for server status and troubleshoot if needed. Then check for ESS status and troubleshoot if needed. Finally, check whether or not the last job had fine=True, add if it didn’t run with fine.

Parameters

label (str) – The species label.

troubleshoot_scan_job(job: arc.job.job.Job, methods: Optional[dict] = None) → Tuple[bool, dict][source]

Troubleshooting rotor scans Using the following methods: 1. freeze: freezing specific internal coordinates or all torsions other than the scan’s pivots 2. inc_res: increasing the scan resolution. 3. change conformer: changing to a conformer with a lower energy

Parameters
  • job (Job) – The scan Job object.

  • methods (dict) –

    The troubleshooting method/s to try:

    {'freeze': <a list of problematic internal coordinates>,
     'inc_res': ``None``,
     'change conformer': <a xyz dict>}
    

Returns: Tuple[bool, dict]:
  • True if the troubleshooting is valid.

  • The actions are actual applied in the troubleshooting.

arc.scheduler.sum_time_delta(timedelta_list: List[datetime.timedelta]) → datetime.timedelta[source]

A helper function for summing datetime.timedelta objects.

Parameters

timedelta_list (list) – Time delta’s to sum.

Returns

The timedelta sum.

Return type

datetime.timedelta