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, 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.

Submission

rush.exess.calculate(mol, driver, method='RestrictedKSDFT', basis='cc-pVDZ', aux_basis=None, standard_orientation=None, force_cartesian_basis_sets=None, scf_keywords=None, frag_keywords=FragKeywords(), ksdft_keywords=_KSDFTDefault.DEFAULT, export_keywords=None, system=None, convert_hdf5_to_json=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts())[source]

Submit a generic EXESS calculation for the topology at topology_path.

Returns a RushRun handle. Call .collect() to wait for the result ref, or use the .fetch() / .save() shortcuts.

Parameters:

  • mol (TRC | TRCRef | Path | str | RushObject | Topology)

  • driver (str)

  • 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 | None)

  • ksdft_keywords (KSDFTKeywords | _KSDFTDefault | None)

  • export_keywords (ExportKeywords | None)

  • system (System | None)

  • convert_hdf5_to_json (bool | None)

  • run_spec (RunSpec)

  • run_opts (RunOpts)

Return type:

RushRun[ResultRef]

rush.exess.energy(mol, method='RestrictedKSDFT', basis='cc-pVDZ', aux_basis=None, standard_orientation=None, force_cartesian_basis_sets=None, scf_keywords=None, frag_keywords=FragKeywords(), ksdft_keywords=_KSDFTDefault.DEFAULT, export_keywords=None, system=None, convert_hdf5_to_json=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts())[source]

Submit an EXESS single-point energy calculation.

Parameters:

  • mol (TRC | TRCRef | Path | str | RushObject | Topology)

  • 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 | None)

  • ksdft_keywords (KSDFTKeywords | _KSDFTDefault | None)

  • export_keywords (ExportKeywords | None)

  • system (System | None)

  • convert_hdf5_to_json (bool | None)

  • run_spec (RunSpec)

  • run_opts (RunOpts)

Return type:

RushRun[ResultRef]

rush.exess.interaction_energy(mol, reference_fragment, method='RestrictedKSDFT', basis='cc-pVDZ', aux_basis=None, standard_orientation=None, force_cartesian_basis_sets=None, scf_keywords=None, frag_keywords=FragKeywords(), ksdft_keywords=_KSDFTDefault.DEFAULT, system=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts())[source]

Submit an EXESS interaction-energy calculation.

Computes the interaction energy between the fragment at index reference_fragment and the rest of the system.

Parameters:

  • mol (TRC | TRCRef | Path | str | RushObject | Topology)

  • reference_fragment (int)

  • 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)

  • ksdft_keywords (KSDFTKeywords | _KSDFTDefault | None)

  • system (System | None)

  • run_spec (RunSpec)

  • run_opts (RunOpts)

Return type:

RushRun[ResultRef]

Input Types

class rush.exess.Model(standard_orientation: StandardOrientationT | None = None, force_cartesian_basis_sets: bool | None = None)[source]
Parameters:

  • standard_orientation (StandardOrientationT | None)

  • force_cartesian_basis_sets (bool | None)

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.

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.

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]
Parameters:

  • max_gpu_memory_mb (int | None)

  • oversubscribe_gpus (bool | None)

  • gpus_per_team (int | None)

  • teams_per_node (int | None)

gpus_per_team: int | None = None

Sets corresponding MPI configuration.

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.

teams_per_node: int | None = None

Sets corresponding MPI configuration.

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]
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)

batch_size: int = 2560

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

bf_cutoff_threshold: float | None = None
compress_ri_b: bool = False

False)

Type:

Compress the B matrix for RI-HF (Default

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_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)

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.

exchange_screening_threshold: float = 1e-05
fock_build_type: FockBuildTypeT = 'HGP'
gradient_screening_threshold: float = 1e-10

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

group_shared_exponents: bool = False
homo_lumo_guess_rotation_angle: float | None = None
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.

max_iters: int = 50

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

store_ri_b_on_host: bool = False
use_ri: bool = False
class rush.exess.FragKeywords(level='Dimer', dimer_cutoff=None, trimer_cutoff=None, tetramer_cutoff=None, cutoff_type=None, distance_metric=None, included_fragments=None, reference_fragment=None, enable_speed=None)[source]

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)

  • reference_fragment (int | None)

  • enable_speed (bool | None)

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.

dimer_cutoff: float | None = None

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

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

Calculation will act as if only those fragments were present.

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.

reference_fragment: int | None = None

Enables interaction-energy mode for the selected fragment.

tetramer_cutoff: float | None = None

See documentation for dimer_cutoff.

trimer_cutoff: float | None = None

See documentation for dimer_cutoff.

class rush.exess.KSDFTKeywords(functional, grid=None, method='BatchDense', use_c_opt=None, sp_threshold=None, dp_threshold=None, batches_per_batch=None)[source]

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)

static resolve(ksdft_keywords, method)[source]

Resolve ksdft_keywords default and warn if explicitly passed with a non-KSDFT method.

Parameters:

  • ksdft_keywords (KSDFTKeywords | _KSDFTDefault | None)

  • method (str)

Return type:

KSDFTKeywords | None

batches_per_batch: int | None = None
dp_threshold: float | None = None
functional: str

KS-DFT functional to use

grid: XCGridParameters | None = None
method: KSDFTMethodT | None = 'BatchDense'
sp_threshold: float | None = None
use_c_opt: bool | None = None
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]

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)

concatenate_hdf5_files: bool | None = None
descriptor_grid: StandardDescriptorGrid | DescriptorGrid | CustomDescriptorGrid | RegularDescriptorGrid | None = None
export_basis_labels: bool | None = None
export_bond_orders: bool | None = None

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

export_chelpg_charges: bool | None = None

ChelpG partial charges for the atoms in the system.

export_density: bool | None = None

Electron density

export_density_descriptors: bool | None = None

Derived values from electron density.

export_esp_descriptors: bool | None = None

Derived values from electrostatic potential.

export_expanded_density: bool | None = None

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

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_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_external_charge_gradient: bool | None = None

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

export_fock: bool | None = None

Fock matrix (?)

export_gradient: bool | None = None

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

export_h_caps: bool | None = None

The generated hydrogen caps for fragments in fragmented systems.

export_h_core: bool | None = None

H core matrix

export_hessian: bool | None = None

If set, must be performing a Hessian calculation.

Type:

NOTE

export_hessian_frequencies: bool | None = None
export_mass_weighted_hessian: bool | None = None
export_molecular_orbital_coeffs: bool | None = None

Fancy… (?)

export_mulliken_charges: bool | None = None

Mulliken charges for the atoms in the system.

export_overlap: bool | None = None

Overlap matrix (?)

export_relaxed_mp2_density_correction: bool | None = None

Relaxed MP2 density correction (?)

flatten_symmetric: bool | None = None

True)

Type:

lower triangle of the matrix. (Default

light_json: bool | None = None
training_db: bool | None = None

Descriptor Grids

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

Constructs a descriptor grid based on the parameters.

Parameters:

  • points_per_shell (int)

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

  • scale (float)

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

Constructs a “standard” descriptor grid.

Parameters:

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

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

Default

class rush.exess.RegularDescriptorGrid(min, max, spacing)[source]

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])

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

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.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]
Parameters:

  • radial_quad (RadialQuadT | None)

  • pruning_scheme (PruningSchemeT | None)

  • consider_weight_zero (float | None)

  • resolution (XCGridResolutionT | None)

  • batching (XCBatchingSchemeT | None)

batching: XCBatchingSchemeT | None = None
consider_weight_zero: float | None = None
pruning_scheme: PruningSchemeT | None = None
radial_quad: RadialQuadT | None = None
resolution: XCGridResolutionT | None = None
class rush.exess.DefaultGridResolution(default_grid: Literal['Fine', 'UltraFine', 'SuperFine', 'TreutlerGM3', 'TreutlerGM5'])[source]
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]
Parameters:

  • radial_size (int)

  • angular_size (int)

angular_size: int
radial_size: int
class rush.exess.ClosestAtomBatching[source]
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]
Parameters:

  • max_size (int | None)

  • max_depth (int | None)

  • max_distance (float | None)

  • combine_small_children (bool | None)

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]
Parameters:

  • max_size (int | None)

  • max_depth (int | None)

  • max_distance (float | None)

  • combine_small_children (bool | None)

combine_small_children: bool | None = None
max_depth: int | None = None
max_distance: float | None = None
max_size: int | None = None
class rush.exess.SpaceFillingBatching(octree: Octree | None = None, target_batch_size: int | None = None)[source]
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]
Parameters:

batch_size (int)

batch_size: int

Result Types

class rush.exess.Result(calc: Calculation, exports: dict[str, Any] | bytes | None = None)[source]
Parameters:

  • calc (Calculation)

  • exports (dict[str, Any] | bytes | None)

calc: Calculation
exports: dict[str, Any] | bytes | None = None
class rush.exess.ResultPaths(calc: pathlib.Path, exports: pathlib.Path | None = None)[source]
Parameters:

  • calc (Path)

  • exports (Path | None)

calc: Path
exports: Path | None = None
class rush.exess.ResultRef(calc, exports=None)[source]

Lightweight reference to EXESS outputs in the Rush object store.

Call fetch() to download and parse into Python dataclasses, or save() to download to local files.

Parameters:
classmethod from_raw_output(res)[source]

Parse raw collect_run output into a ResultRef.

Parameters:

res (Any)

Return type:

ResultRef

fetch(extract=True)[source]

Download EXESS outputs and parse into Python dataclasses.

Exported outputs are left lightly processed for now: - JSON exports are returned as a raw dict - HDF5 exports are returned as extracted file bytes by default - HDF5 exports are returned as raw tar.zst bytes when extract=False

Parameters:

extract (bool) – Whether to extract HDF5 tarball exports before returning them.

Returns:

Parsed EXESS calculation data plus an optional export payload.

Return type:

Result

save(extract=True)[source]

Download and save EXESS outputs to the workspace.

Parameters:

extract – Whether to extract HDF5 tarball exports before saving them.

Returns:

Local paths for the saved calculation output and optional export output.

Return type:

ResultPaths

calc: RushObject
exports: RushObject | dict[str, RushObject] | None = None
class rush.exess.Calculation(calculation_time: float, qmmbe: ManyBodyExpansion)[source]
Parameters:
classmethod from_dict(data)[source]
Parameters:

data (dict[str, Any])

Return type:

Calculation

calculation_time: float
qmmbe: ManyBodyExpansion
class rush.exess.ManyBodyExpansion(method: str, nmers: list[list[Nmer]], distance_metric: str | None = None, distance_method: str | None = None, reference_fragment: FragmentRef | None = None, expanded_hf_energy: float | None = None, classical_water_energy: float | None = None, expanded_mp2_ss_correction: float | None = None, expanded_mp2_os_correction: float | None = None, expanded_ccsd_correction: float | None = None, expanded_density: TensorLike | None = None, expanded_hf_gradients: list[float] | None = None, expanded_mp2_gradients: list[float] | None = None, num_iters: int | None = None)[source]
Parameters:

  • method (str)

  • nmers (list[list[Nmer]])

  • distance_metric (str | None)

  • distance_method (str | None)

  • reference_fragment (FragmentRef | None)

  • expanded_hf_energy (float | None)

  • classical_water_energy (float | None)

  • expanded_mp2_ss_correction (float | None)

  • expanded_mp2_os_correction (float | None)

  • expanded_ccsd_correction (float | None)

  • expanded_density (TensorLike | None)

  • expanded_hf_gradients (list[float] | None)

  • expanded_mp2_gradients (list[float] | None)

  • num_iters (int | None)

classmethod from_dict(data)[source]
Parameters:

data (dict[str, Any])

Return type:

ManyBodyExpansion

classical_water_energy: float | None = None
distance_method: str | None = None
distance_metric: str | None = None
expanded_ccsd_correction: float | None = None
expanded_density: TensorLike | None = None
expanded_hf_energy: float | None = None
expanded_hf_gradients: list[float] | None = None
expanded_mp2_gradients: list[float] | None = None
expanded_mp2_os_correction: float | None = None
expanded_mp2_ss_correction: float | None = None
method: str
nmers: list[list[Nmer]]
num_iters: int | None = None
reference_fragment: FragmentRef | None = None
class rush.exess.Nmer(fragments: list[FragmentRef], density: TensorLike | None = None, fock: TensorLike | None = None, overlap: TensorLike | None = None, h_core: TensorLike | None = None, coeffs_initial: TensorLike | None = None, coeffs_final: TensorLike | None = None, molecular_orbital_energies: list[float] | None = None, hf_gradients: list[float] | None = None, mp2_gradients: list[float] | None = None, hf_energy: float | None = None, mp2_ss_correction: float | None = None, mp2_os_correction: float | None = None, ccsd_correction: float | None = None, s_squared_eigenvalue: float | None = None, delta_hf_energy: float | None = None, delta_mp2_ss_correction: float | None = None, delta_mp2_os_correction: float | None = None, mulliken_charges: list[float] | None = None, chelpg_charges: list[float] | None = None, fragment_distance: float | None = None, bond_orders: list[list[float]] | None = None, h_caps: list[AtomRef] | None = None, num_iters: int | None = None, num_basis_fns: int | None = None)[source]
Parameters:

  • fragments (list[FragmentRef])

  • density (TensorLike | None)

  • fock (TensorLike | None)

  • overlap (TensorLike | None)

  • h_core (TensorLike | None)

  • coeffs_initial (TensorLike | None)

  • coeffs_final (TensorLike | None)

  • molecular_orbital_energies (list[float] | None)

  • hf_gradients (list[float] | None)

  • mp2_gradients (list[float] | None)

  • hf_energy (float | None)

  • mp2_ss_correction (float | None)

  • mp2_os_correction (float | None)

  • ccsd_correction (float | None)

  • s_squared_eigenvalue (float | None)

  • delta_hf_energy (float | None)

  • delta_mp2_ss_correction (float | None)

  • delta_mp2_os_correction (float | None)

  • mulliken_charges (list[float] | None)

  • chelpg_charges (list[float] | None)

  • fragment_distance (float | None)

  • bond_orders (list[list[float]] | None)

  • h_caps (list[AtomRef] | None)

  • num_iters (int | None)

  • num_basis_fns (int | None)

classmethod from_dict(data)[source]
Parameters:

data (dict[str, Any])

Return type:

Nmer

bond_orders: list[list[float]] | None = None
ccsd_correction: float | None = None
chelpg_charges: list[float] | None = None
coeffs_final: TensorLike | None = None
coeffs_initial: TensorLike | None = None
delta_hf_energy: float | None = None
delta_mp2_os_correction: float | None = None
delta_mp2_ss_correction: float | None = None
density: TensorLike | None = None
fock: TensorLike | None = None
fragment_distance: float | None = None
fragments: list[FragmentRef]
h_caps: list[AtomRef] | None = None
h_core: TensorLike | None = None
hf_energy: float | None = None
hf_gradients: list[float] | None = None
molecular_orbital_energies: list[float] | None = None
mp2_gradients: list[float] | None = None
mp2_os_correction: float | None = None
mp2_ss_correction: float | None = None
mulliken_charges: list[float] | None = None
num_basis_fns: int | None = None
num_iters: int | None = None
overlap: TensorLike | None = None
s_squared_eigenvalue: float | None = None