EXESS

For detailed documentation on EXESS capabilities, keywords, and examples, see the EXESS Documentation.

EXESS module helpers for the Rush Python client.

EXESS supports whole-system energy calculations (fragmented or unfragmented), interaction energy between a fragment and the rest of the system, geometry optimization, simulations, and gradient/Hessian calculations. It supports multiple levels of theory (e.g., restricted/unrestricted HF, RI-MP2, DFT), flexible basis set selection, and configurable n-mer fragmentation levels.

type rush.exess.MethodT = Literal['RestrictedHF', 'UnrestrictedHF', 'RestrictedKSDFT', 'RestrictedRIMP2', 'UnrestrictedRIMP2']
type rush.exess.BasisT = Literal['3-21G', '4-31G', '5-21G', '6-21G', '6-31G', '6-31G(2df,p)', '6-31G(3df,3pd)', '6-31G*', '6-31G**', '6-31+G', '6-31+G*', '6-31+G**', '6-31++G', '6-31++G*', '6-31++G**', 'PCSeg-0', 'PCSeg-1', 'STO-2G', 'STO-3G', 'STO-4G', 'STO-5G', 'STO-6G', 'aug-cc-pVDZ', 'aug-cc-pVTZ', 'cc-pVDZ', 'cc-pVTZ', 'def2-SVP', 'def2-TZVP', 'def2-TZVPD', 'def2-TZVPP', 'def2-TZVPPD']
type rush.exess.AuxBasisT = Literal['6-31G**-RIFIT', 'aug-cc-pVDZ-RIFIT', 'aug-cc-pVTZ-RIFIT', 'cc-pVDZ-RIFIT', 'cc-pVTZ-RIFIT', 'def2-SVP-RIFIT', 'def2-TZVP-RIFIT', 'def2-TZVPD-RIFIT', 'def2-TZVPP-RIFIT', 'def2-TZVPPD-RIFIT']
type rush.exess.StandardOrientationT = Literal['None', 'FullSystem', 'PerFragment']
class rush.exess.Model(standard_orientation: StandardOrientationT | None = None, force_cartesian_basis_sets: bool | None = None)[source]

Bases: object

Parameters:
standard_orientation: StandardOrientationT | None = None

Determines if the system is tranformed into a “standard orientation” during the calculations. (Default: “FullSystem”) Setting this value to “None” prevents any transformation from happening, such that the output is exactly aligned with the input.

force_cartesian_basis_sets: bool | None = None

Determines whether spherical or Cartesian basis sets will be used. (Default: “True”) Setting this value to “False” could provide speedup or memory savings in some cases, but certain features require Cartesian basis sets.

class rush.exess.System(max_gpu_memory_mb: int | None = None, oversubscribe_gpus: bool | None = None, gpus_per_team: int | None = None, teams_per_node: int | None = None)[source]

Bases: object

Parameters:

  • max_gpu_memory_mb (int | None)

  • oversubscribe_gpus (bool | None)

  • gpus_per_team (int | None)

  • teams_per_node (int | None)

max_gpu_memory_mb: int | None = None

Maximum memory to allocate to the GPU for EXESS’s dedicated use. Try setting this to limit or increase the memory if EXESS’s automatic determination of how much to allocate is not working properly (and probably file a bug too).

oversubscribe_gpus: bool | None = None

Allow EXESS to over-allocate memory on GPUs.

gpus_per_team: int | None = None

Sets corresponding MPI configuration.

teams_per_node: int | None = None

Sets corresponding MPI configuration.

type rush.exess.ConvergenceMetricT = Literal['Energy', 'DIIS', 'Density']
type rush.exess.FockBuildTypeT = Literal['HGP', 'UM09', 'RI']
class rush.exess.SCFKeywords(max_iters: int = 50, max_diis_history_length: int = 8, batch_size: int = 2560, convergence_metric: ConvergenceMetricT = 'DIIS', convergence_threshold: float = 1e-06, density_threshold: float = 1e-10, gradient_screening_threshold: float = 1e-10, bf_cutoff_threshold: float | None = None, density_basis_set_projection_fallback_enabled: bool | None = None, use_ri: bool = False, store_ri_b_on_host: bool = False, compress_ri_b: bool = False, homo_lumo_guess_rotation_angle: float | None = None, fock_build_type: FockBuildTypeT = 'HGP', exchange_screening_threshold: float = 1e-05, group_shared_exponents: bool = False)[source]

Bases: object

Parameters:

  • max_iters (int)

  • max_diis_history_length (int)

  • batch_size (int)

  • convergence_metric (ConvergenceMetricT)

  • convergence_threshold (float)

  • density_threshold (float)

  • gradient_screening_threshold (float)

  • bf_cutoff_threshold (float | None)

  • density_basis_set_projection_fallback_enabled (bool | None)

  • use_ri (bool)

  • store_ri_b_on_host (bool)

  • compress_ri_b (bool)

  • homo_lumo_guess_rotation_angle (float | None)

  • fock_build_type (FockBuildTypeT)

  • exchange_screening_threshold (float)

  • group_shared_exponents (bool)

max_iters: int = 50

Max SCF iterations performed. Ajust depending on the convergence_threshold chosen.

max_diis_history_length: int = 8

Use this keyword to control the size of the DIIS extrapolation space, i.e. how many past iteration matrices will be used to extrapolate the Fock matrix. A larger number will result in slightly higher memory use. This can become a problem when dealing with large systems without fragmentation.

batch_size: int = 2560

Number of shell pair batches stored in the shell-pair batch bin container.

convergence_metric: ConvergenceMetricT = 'DIIS'

Metric to use for SCF convergence. Using energy as the convergence metric can lead to early convergence which can produce unideal orbitals for MP2 calculations.

convergence_threshold: float = 1e-06

SCF convergence threshold

density_threshold: float = 1e-10

Besides the Cauchy-Schwarz screening, inside each integral kernel the integrals are further screened against the density matrix. This threshold controls at which value an integral is considered to be negligible. Decreasing this threshold will lead to significantly faster SCF times at the possible cost of accuracy. Increasing it to 1E-11 and 1E-12 will lead to longer SCF times because more integrals will be evaluated. However, for methods such as tetramer level MBE this can better the accuracy of the program. This will also produce crisper orbitals for MP2 calculations.

gradient_screening_threshold: float = 1e-10

Like the density, the integrals are further screened against the gradient matrix.

bf_cutoff_threshold: float | None = None
density_basis_set_projection_fallback_enabled: bool | None = None

Fall back to STO-3G basis set for calcuulation and project up if SCF is unconverged (Default: True)

use_ri: bool = False
store_ri_b_on_host: bool = False
compress_ri_b: bool = False

False)

Type:

Compress the B matrix for RI-HF (Default

homo_lumo_guess_rotation_angle: float | None = None
fock_build_type: FockBuildTypeT = 'HGP'
exchange_screening_threshold: float = 1e-05
group_shared_exponents: bool = False
type rush.exess.FragmentLevelT = Literal['Monomer', 'Dimer', 'Trimer', 'Tetramer']
type rush.exess.CutoffTypeT = Literal['Centroid', 'ClosestPair']
type rush.exess.DistanceMetricT = Literal['Max', 'Average', 'Min']
class rush.exess.FragKeywords(level='Dimer', dimer_cutoff=None, trimer_cutoff=None, tetramer_cutoff=None, cutoff_type=None, distance_metric=None, included_fragments=None, enable_speed=None)[source]

Bases: object

Configure the fragmentation of the system.

Defaults are provided for all relevant levels. NOTE: cutoffs for each level must be less than or equal to those at the lower levels.

Parameters:

  • level (FragmentLevelT)

  • dimer_cutoff (float | None)

  • trimer_cutoff (float | None)

  • tetramer_cutoff (float | None)

  • cutoff_type (CutoffTypeT | None)

  • distance_metric (DistanceMetricT | None)

  • included_fragments (list[int | FragmentRef] | None)

  • enable_speed (bool | None)

level: FragmentLevelT = 'Dimer'

Controls at which level the many body expansion is truncated. I.e., what order of n-mers to create fragments for when fragmenting. Reasonable values range from Dimer to Tetramer, with Dimers being a quick and efficient but still meaningful initial configuration when experimenting.

dimer_cutoff: float | None = None

The cutoffs control at what distance a polymer won’t be calculated. All distances are in Angstroms.

trimer_cutoff: float | None = None

See documentation for dimer_cutoff.

tetramer_cutoff: float | None = None

See documentation for dimer_cutoff.

cutoff_type: CutoffTypeT | None = None

Default is “ClosestPair”, which uses the closest pair of atoms in each fragment to assess their distance rather than the distance between fragment centroids.

distance_metric: DistanceMetricT | None = None
included_fragments: list[int | FragmentRef] | None = None

Calculation will act as if only those fragments were present.

enable_speed: bool | None = None
class rush.exess.StandardDescriptorGrid(value)[source]

Bases: object

Constructs a “standard” descriptor grid.

Parameters:

value (Literal['Fine', 'UltraFine', 'SuperFine', 'TreutlerGM3', 'TreutlerGM5'])

value: Literal['Fine', 'UltraFine', 'SuperFine', 'TreutlerGM3', 'TreutlerGM5']

Default

class rush.exess.DescriptorGrid(points_per_shell, order, scale)[source]

Bases: object

Constructs a descriptor grid based on the parameters.

Parameters:

  • points_per_shell (int)

  • order (Literal['One', 'Two'])

  • scale (float)

points_per_shell: int
order: Literal['One', 'Two']
scale: float
class rush.exess.CustomDescriptorGrid(value)[source]

Bases: object

Construct a totally custom descriptor grid with each point being explicitly specified by its (x, y, z) coordinates. Points are specified one after the other, e.g. [x1, y1, z1, x2, y2, z2, …].

Parameters:

value (list[float])

value: list[float]
class rush.exess.RegularDescriptorGrid(min, max, spacing)[source]

Bases: object

Construct a regular Cartesian descriptor grid with evenly-spaced points between the minimum and maximum points specified, at the defined spacing in each dimension.

Parameters:

  • min (list[float])

  • max (list[float])

  • spacing (list[float])

min: list[float]
max: list[float]
spacing: list[float]
class rush.exess.ExportKeywords(export_density=None, export_relaxed_mp2_density_correction=None, export_fock=None, export_overlap=None, export_h_core=None, export_expanded_density=None, export_expanded_gradient=None, export_molecular_orbital_coeffs=None, export_gradient=None, export_external_charge_gradient=None, export_mulliken_charges=None, export_chelpg_charges=None, export_bond_orders=None, export_h_caps=None, export_density_descriptors=None, export_esp_descriptors=None, export_expanded_esp_descriptors=None, export_basis_labels=None, export_hessian=None, export_mass_weighted_hessian=None, export_hessian_frequencies=None, flatten_symmetric=None, light_json=None, concatenate_hdf5_files=None, training_db=None, descriptor_grid=None)[source]

Bases: object

Configure the exported outputs of the system. Outputs are in both JSON and HDF5 format (some just one or the other). Most outputs are in the HDF5 file only.

Parameters:

  • export_density (bool | None)

  • export_relaxed_mp2_density_correction (bool | None)

  • export_fock (bool | None)

  • export_overlap (bool | None)

  • export_h_core (bool | None)

  • export_expanded_density (bool | None)

  • export_expanded_gradient (bool | None)

  • export_molecular_orbital_coeffs (bool | None)

  • export_gradient (bool | None)

  • export_external_charge_gradient (bool | None)

  • export_mulliken_charges (bool | None)

  • export_chelpg_charges (bool | None)

  • export_bond_orders (bool | None)

  • export_h_caps (bool | None)

  • export_density_descriptors (bool | None)

  • export_esp_descriptors (bool | None)

  • export_expanded_esp_descriptors (bool | None)

  • export_basis_labels (bool | None)

  • export_hessian (bool | None)

  • export_mass_weighted_hessian (bool | None)

  • export_hessian_frequencies (bool | None)

  • flatten_symmetric (bool | None)

  • light_json (bool | None)

  • concatenate_hdf5_files (bool | None)

  • training_db (bool | None)

  • descriptor_grid (StandardDescriptorGrid | DescriptorGrid | CustomDescriptorGrid | RegularDescriptorGrid | None)

export_density: bool | None = None

Electron density

export_relaxed_mp2_density_correction: bool | None = None

Relaxed MP2 density correction (?)

export_fock: bool | None = None

Fock matrix (?)

export_overlap: bool | None = None

Overlap matrix (?)

export_h_core: bool | None = None

H core matrix

export_expanded_density: bool | None = None

Provides the whole density matrix for entire fragment system, rather than per-fragment matrices.

export_expanded_gradient: bool | None = None

Provides the whole gradient matrix for entire fragment system, rather than per-fragment matrices. NOTE: If set, must be performing a gradient calculation.

export_molecular_orbital_coeffs: bool | None = None

Fancy… (?)

export_gradient: bool | None = None

Energy gradient values (as used in Optimization and QMMM). NOTE: If set, must be performing a gradient calculation.

export_external_charge_gradient: bool | None = None

If external charges are used, export the gradient for these point charges.

export_mulliken_charges: bool | None = None

Mulliken charges for the atoms in the system.

export_chelpg_charges: bool | None = None

ChelpG partial charges for the atoms in the system.

export_bond_orders: bool | None = None

Believed to be a pass-through from the input connectivity.

export_h_caps: bool | None = None

The generated hydrogen caps for fragments in fragmented systems.

export_density_descriptors: bool | None = None

Derived values from electron density.

export_esp_descriptors: bool | None = None

Derived values from electrostatic potential.

export_expanded_esp_descriptors: bool | None = None

Provides the whole esp descriptor matrix for entire fragment system, rather than per-fragment matrices. NOTE: Causes memory errors.

export_basis_labels: bool | None = None
export_hessian: bool | None = None

If set, must be performing a Hessian calculation.

Type:

NOTE

export_mass_weighted_hessian: bool | None = None
export_hessian_frequencies: bool | None = None
flatten_symmetric: bool | None = None

True)

Type:

lower triangle of the matrix. (Default

light_json: bool | None = None
concatenate_hdf5_files: bool | None = None
training_db: bool | None = None
descriptor_grid: StandardDescriptorGrid | DescriptorGrid | CustomDescriptorGrid | RegularDescriptorGrid | None = None
type rush.exess.RadialQuadT = Literal['MuraKnowles', 'MurrayHandyLaming', 'TreutlerAldrichs']
type rush.exess.PruningSchemeT = Literal['Unpruned', 'Robust', 'Treutler']
class rush.exess.DefaultGridResolution(default_grid: Literal['Fine', 'UltraFine', 'SuperFine', 'TreutlerGM3', 'TreutlerGM5'])[source]

Bases: object

Parameters:

default_grid (Literal['Fine', 'UltraFine', 'SuperFine', 'TreutlerGM3', 'TreutlerGM5'])

default_grid: Literal['Fine', 'UltraFine', 'SuperFine', 'TreutlerGM3', 'TreutlerGM5']

Default

class rush.exess.CustomGridResolution(radial_size: int, angular_size: int)[source]

Bases: object

Parameters:

  • radial_size (int)

  • angular_size (int)

radial_size: int
angular_size: int
type rush.exess.XCGridResolutionT = DefaultGridResolution | CustomGridResolution
class rush.exess.ClosestAtomBatching[source]

Bases: object

class rush.exess.Octree(max_size: int | None = None, max_depth: int | None = None, max_distance: float | None = None, combine_small_children: bool | None = None)[source]

Bases: object

Parameters:

  • max_size (int | None)

  • max_depth (int | None)

  • max_distance (float | None)

  • combine_small_children (bool | None)

max_size: int | None = None
max_depth: int | None = None
max_distance: float | None = None
combine_small_children: bool | None = None
class rush.exess.OctreeBatching(max_size: int | None = None, max_depth: int | None = None, max_distance: float | None = None, combine_small_children: bool | None = None)[source]

Bases: Octree

Parameters:

  • max_size (int | None)

  • max_depth (int | None)

  • max_distance (float | None)

  • combine_small_children (bool | None)

class rush.exess.SpaceFillingBatching(octree: Octree | None = None, target_batch_size: int | None = None)[source]

Bases: object

Parameters:

  • octree (Octree | None)

  • target_batch_size (int | None)

octree: Octree | None = None
target_batch_size: int | None = None
class rush.exess.GauXCBatching(batch_size: int)[source]

Bases: object

Parameters:

batch_size (int)

batch_size: int
type rush.exess.XCBatchingSchemeT = ClosestAtomBatching | OctreeBatching | SpaceFillingBatching | GauXCBatching
class rush.exess.XCGridParameters(radial_quad: RadialQuadT | None = None, pruning_scheme: PruningSchemeT | None = None, consider_weight_zero: float | None = None, resolution: XCGridResolutionT | None = None, batching: XCBatchingSchemeT | None = None)[source]

Bases: object

Parameters:
radial_quad: RadialQuadT | None = None
pruning_scheme: PruningSchemeT | None = None
consider_weight_zero: float | None = None
resolution: XCGridResolutionT | None = None
batching: XCBatchingSchemeT | None = None
type rush.exess.KSDFTMethodT = Literal['GauXC', 'Dense', 'BatchDense', 'Direct', 'SemiDirect']
class rush.exess.KSDFTKeywords(functional, grid=None, method='BatchDense', use_c_opt=None, sp_threshold=None, dp_threshold=None, batches_per_batch=None)[source]

Bases: object

Configure runs done with the RestrictedKSDFT method.

Parameters:

  • functional (str)

  • grid (XCGridParameters | None)

  • method (KSDFTMethodT | None)

  • use_c_opt (bool | None)

  • sp_threshold (float | None)

  • dp_threshold (float | None)

  • batches_per_batch (int | None)

functional: str

KS-DFT functional to use

grid: XCGridParameters | None = None
method: KSDFTMethodT | None = 'BatchDense'
use_c_opt: bool | None = None
sp_threshold: float | None = None
dp_threshold: float | None = None
batches_per_batch: int | None = None
class rush.exess.Trajectory(interval=None, start=None, end=None, include_waters=None)[source]

Bases: object

Configure the output of QMMM runs. By default, will provide all atoms at every frame.

Parameters:

  • interval (int | None)

  • start (int | None)

  • end (int | None)

  • include_waters (int | None)

interval: int | None = None

Save every n frames to the trajectory, where n is the interval specified.

start: int | None = None

The frame at which to start the trajectory.

end: int | None = None

The frame at which to end the trajectory.

include_waters: int | None = None

Whether to include waters in the trajectory. Convenient for reducing output size.

class rush.exess.Restraints(k=None, fixed_atoms=None, free_atoms=None, fixed_fragments=None, free_fragments=None, fix_heavy=None)[source]

Bases: object

Restrain atoms using an external force proportional to its distance from its original position, scaled by k (larger values mean a stronger restraint).

All atoms can be fixed by specifying free_atoms = [].

Parameters:

  • k (float | None)

  • fixed_atoms (list[int] | None)

  • free_atoms (list[int] | None)

  • fixed_fragments (list[int] | None)

  • free_fragments (list[int] | None)

  • fix_heavy (bool | None)

k: float | None = None

Scaling factor for restraints (larger values mean a stronger restraint).

fixed_atoms: list[int] | None = None

Which atoms to hold fixed. All fixed/free parameters are mutually exclusive.

free_atoms: list[int] | None = None

Which atoms to keep unfixed. All fixed/free parameters are mutually exclusive.

fixed_fragments: list[int] | None = None

Which fragments to hold fixed. All fixed/free parameters are mutually exclusive.

free_fragments: list[int] | None = None

Which fragments to keep unfixed. All fixed/free parameters are mutually exclusive.

fix_heavy: bool | None = None

Flag to easily enable fixing all heavy atoms only. Mutually exclusive with fixed/free parameters.

rush.exess.exess(topology_path, driver='Energy', method='RestrictedHF', basis='cc-pVDZ', aux_basis=None, standard_orientation=None, force_cartesian_basis_sets=None, scf_keywords=None, frag_keywords=FragKeywords(), ksdft_keywords=None, export_keywords=None, system=None, convert_hdf5_to_json=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts(), collect=False)[source]

Compute the energy of the system in the QDX topology file at topology_path.

Parameters:
rush.exess.energy(topology_path, method='RestrictedHF', basis='cc-pVDZ', aux_basis=None, standard_orientation=None, force_cartesian_basis_sets=None, scf_keywords=None, frag_keywords=FragKeywords(), ksdft_keywords=None, export_keywords=None, system=None, convert_hdf5_to_json=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts(), collect=False)[source]
Parameters:
rush.exess.save_energy_outputs(res, extract=True)[source]
Parameters:

res (list[dict] | tuple[dict] | tuple[dict, dict] | RunError)

Return type:

Path | tuple[Path, Path] | RunError

rush.exess.interaction_energy(topology_path, reference_fragment, method='RestrictedHF', basis='cc-pVDZ', aux_basis=None, standard_orientation=None, force_cartesian_basis_sets=None, scf_keywords=None, frag_keywords=FragKeywords(), system=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts(), collect=False)[source]

Compute the interaction energy between the fragment with index reference_fragment and the rest of the system in the toplogy file at topology_path.

Parameters:
rush.exess.chelpg(topology_path, system=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts(), collect=False)[source]

Compute the CHELPG partial charges for all atoms of the system in the topology file at topology_path.

Parameters:

  • topology_path (Path | str)

  • system (System | None)

  • run_spec (RunSpec)

  • run_opts (RunOpts)

  • collect (bool)

rush.exess.qmmm(topology_path, n_timesteps, residues_path=None, dt_ps=2e-3, temperature_kelvin=290.0, pressure_atm=None, restraints=None, trajectory=Trajectory(), gradient_finite_difference_step_size=None, method='RestrictedHF', basis='STO-3G', aux_basis=None, standard_orientation=None, force_cartesian_basis_sets=None, scf_keywords=None, frag_keywords=FragKeywords(), qm_fragments=None, mm_fragments=None, ml_fragments=None, system=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts(), collect=False)[source]

Run a QMMM simulation of the system in the QDX topology and residues files at topology_path and residues_path.

Specifying the numberof timesteps is mandatory. If pressure is None, an NVT ensemble is used; if pressure is specified, an NPT ensemble is used. Fragments can be specified as QM, MM, or ML fragments via the respective parameters. If two fragment list parameters are specified, the rest of the fragments are inferred to be of the other type. If three fragment list parameters are specified, each fragment must be placed in exactly one of the lists. It is invalid to specify one fragment list parameter.

Parameters:

  • topology_path (Path | str)

  • n_timesteps (int)

  • residues_path (Path | str | None)

  • dt_ps (float)

  • temperature_kelvin (float)

  • pressure_atm (float | None)

  • restraints (Restraints | None)

  • trajectory (Trajectory)

  • gradient_finite_difference_step_size (float | None)

  • method (MethodT)

  • basis (BasisT)

  • aux_basis (AuxBasisT | None)

  • standard_orientation (StandardOrientationT | None)

  • force_cartesian_basis_sets (bool | None)

  • scf_keywords (SCFKeywords | None)

  • frag_keywords (FragKeywords)

  • qm_fragments (list[int] | None)

  • mm_fragments (list[int] | None)

  • ml_fragments (list[int] | None)

  • system (System | None)

  • run_spec (RunSpec)

  • run_opts (RunOpts)

  • collect (bool)

class rush.exess.OptimizationConvergenceCriteria(metric: str | None = None, gradient_threshold: float | None = None, delta_energy_threshold: float | None = None, step_component_threshold: float | None = None)[source]

Bases: object

Parameters:

  • metric (str | None)

  • gradient_threshold (float | None)

  • delta_energy_threshold (float | None)

  • step_component_threshold (float | None)

metric: str | None = None
gradient_threshold: float | None = None
delta_energy_threshold: float | None = None
step_component_threshold: float | None = None
type rush.exess.CoordinateSystemT = Literal['Cartesian', 'NaturalInternal', 'DelocalisedInternal']
type rush.exess.HessianGuessTypeT = Literal['Identity', 'ScaledIdentity', 'Schlegel', 'Lindh']
type rush.exess.OptimizationAlgorithmTypeT = Literal['EigenvectorFollowing', 'TrustRegionAugmentedHessian', 'LBFGS']
class rush.exess.TrustRegionKeywords(initial_radius: float | None = None, max_radius: float | None = None, min_radius: float | None = None, increase_factor: float | None = None, decrease_factor: float | None = None, constrict_factor: float | None = None, increase_threshold: float | None = None, decrease_threshold: float | None = None, rejection_threshold: float | None = None)[source]

Bases: object

Parameters:

  • initial_radius (float | None)

  • max_radius (float | None)

  • min_radius (float | None)

  • increase_factor (float | None)

  • decrease_factor (float | None)

  • constrict_factor (float | None)

  • increase_threshold (float | None)

  • decrease_threshold (float | None)

  • rejection_threshold (float | None)

initial_radius: float | None = None
max_radius: float | None = None
min_radius: float | None = None
increase_factor: float | None = None
decrease_factor: float | None = None
constrict_factor: float | None = None
increase_threshold: float | None = None
decrease_threshold: float | None = None
rejection_threshold: float | None = None
type rush.exess.LBFGSLinesearchT = Literal['MoreThuente', 'BacktrackingArmijo', 'BacktrackingWolfe', 'BacktrackingStrongWolfe']
class rush.exess.LBFGSKeywords(linesearch: LBFGSLinesearchT = 'BacktrackingStrongWolfe', n_corrections: int | None = None, epsilon: float | None = None, max_linesearch: int | None = None, gtol: float | None = None)[source]

Bases: object

Parameters:

  • linesearch (LBFGSLinesearchT)

  • n_corrections (int | None)

  • epsilon (float | None)

  • max_linesearch (int | None)

  • gtol (float | None)

linesearch: LBFGSLinesearchT = 'BacktrackingStrongWolfe'
n_corrections: int | None = None
epsilon: float | None = None
max_linesearch: int | None = None
gtol: float | None = None
class rush.exess.OptimizationKeywords(convergence_criteria: OptimizationConvergenceCriteria | None = None, optimizer_reset_interval: int | None = None, coordinate_system: CoordinateSystemT | None = None, constraints: list[list[int]] | None = None, hessian_guess: HessianGuessTypeT | None = None, algorithm: OptimizationAlgorithmTypeT | None = None, lbfgs_keywords: LBFGSKeywords | None = None, frozen_distance_slippage_tolerance_angstroms: float | None = None, frozen_angle_slippage_tolerance_degrees: float | None = None, trust_region_keywords: TrustRegionKeywords | None = None, fixed_atoms: list[int] | None = None, free_atoms: list[int] | None = None, fixed_fragments: list[int] | None = None, free_fragments: list[int] | None = None, fix_heavy: bool | None = None)[source]

Bases: object

Parameters:

  • convergence_criteria (OptimizationConvergenceCriteria | None)

  • optimizer_reset_interval (int | None)

  • coordinate_system (CoordinateSystemT | None)

  • constraints (list[list[int]] | None)

  • hessian_guess (HessianGuessTypeT | None)

  • algorithm (OptimizationAlgorithmTypeT | None)

  • lbfgs_keywords (LBFGSKeywords | None)

  • frozen_distance_slippage_tolerance_angstroms (float | None)

  • frozen_angle_slippage_tolerance_degrees (float | None)

  • trust_region_keywords (TrustRegionKeywords | None)

  • fixed_atoms (list[int] | None)

  • free_atoms (list[int] | None)

  • fixed_fragments (list[int] | None)

  • free_fragments (list[int] | None)

  • fix_heavy (bool | None)

convergence_criteria: OptimizationConvergenceCriteria | None = None
optimizer_reset_interval: int | None = None
coordinate_system: CoordinateSystemT | None = None
constraints: list[list[int]] | None = None
hessian_guess: HessianGuessTypeT | None = None
algorithm: OptimizationAlgorithmTypeT | None = None
lbfgs_keywords: LBFGSKeywords | None = None
frozen_distance_slippage_tolerance_angstroms: float | None = None
frozen_angle_slippage_tolerance_degrees: float | None = None
trust_region_keywords: TrustRegionKeywords | None = None
fixed_atoms: list[int] | None = None
free_atoms: list[int] | None = None
fixed_fragments: list[int] | None = None
free_fragments: list[int] | None = None
fix_heavy: bool | None = None
rush.exess.optimization(topology_path, max_iters, residues_path=None, optimization_keywords=OptimizationKeywords(), method='RestrictedHF', basis='cc-pVDZ', aux_basis=None, standard_orientation=None, force_cartesian_basis_sets=None, scf_keywords=None, qm_fragments=None, mm_fragments=None, ml_fragments=None, system=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts(), collect=False)[source]

Run optimization on the system in the QDX topology and residues files at topology_path.

Specifying the maximum iterations is mandatory. Fragment-based QM calculation is not supported, but fragments can be used for specifying regions as QM, MM, or ML. If two fragment list parameters are specified, the rest of the fragments are inferred to be of the other type. If three fragment list parameters are specified, each fragment must be placed in exactly one of the lists. It is invalid to specify one fragment list parameter.

Parameters:

  • topology_path (Path | str)

  • max_iters (int)

  • residues_path (Path | str | None)

  • optimization_keywords (OptimizationKeywords)

  • method (MethodT)

  • basis (BasisT)

  • aux_basis (AuxBasisT | None)

  • standard_orientation (StandardOrientationT | None)

  • force_cartesian_basis_sets (bool | None)

  • scf_keywords (SCFKeywords | None)

  • qm_fragments (list[int] | None)

  • mm_fragments (list[int] | None)

  • ml_fragments (list[int] | None)

  • system (System | None)

  • run_spec (RunSpec)

  • run_opts (RunOpts)

  • collect (bool)