PastIndexableTuple: PastIndexableTuple
StateSpaceWrapper: StateSpaceWrapper
ProjectionOperatorWrapper: ProjectionOperatorWrapper
ProjectedOperator: ProjectedOperator
default_strong_coupling_threshold: float
PTResults: PTResults

__init__(self, perturbations, states, coupled_states=None, order=2, total_space=None, flat_total_space=None, state_space_iterations=None, state_space_terms=None, state_space_filters=None, extended_state_space_filter_generator=None, extended_state_space_postprocessor=None, target_property_rules=None, allow_sakurai_degs=False, allow_post_PT_calc=True, modify_degenerate_perturbations=False, gaussian_resonance_handling=False, ignore_odd_order_energies=False, intermediate_normalization=False, reorthogonalize_degenerate_states=None, check_overlap=True, zero_element_warning=True, degenerate_states=None, degeneracy_handlers=None, handle_strong_couplings=False, local_coupling_hamiltonian=None, local_coupling_order=None, low_frequency_mode_cutoff=0.00115, zero_order_energy_corrections=None, nondeg_hamiltonian_precision=3, memory_constrained=False, keep_hamiltonians=None, logger=None, parallelizer=None, checkpointer=None, results=None, checkpoint_keys=None, use_cached_representations=False, use_cached_basis=False): 

• perturbations: Iterable[Representation]

• states: BasisStateSpace

• coupled_states: BasisMultiStateSpace

• order: Any

• degenerate_states: Any

• degeneracy_mode: Any

• logger: Any

• parallelizer: Any

• checkpointer: Any

• results: Any

@property
coupled_states(self): 

• :returns: _

@property
total_space_dim(self): 

• :returns: _

@property
flat_total_space(self): 

• :returns: _

@property
total_state_space(self): 

• :returns: _

@property
representations(self): 

• :returns: Iterable[SparseArray]

@property
degenerate_spaces(self): 

• :returns: _

@classmethod
merge_deg_spaces(cls, new_states): 

@property
zero_order_energies(self): 

• :returns: _

apply_VPT(self): 

Applies perturbation theory to the held basis of states using the built representations and degenerate state spaces

• :returns: PerturbationTheoryCorrections

get_VPT_representations(self): 

Gets the sparse representations of the passed perturbation inside the basis of coupled states.

• :returns: Iterable[SparseArray]

extend_VPT_representations(self, new_flat_space, new_states): 

load_state_spaces(self): 

• :returns: _

extend_state_spaces(self, new_targets, degenerate_states=None): 

load_coupled_spaces(self, degenerate_spaces=None, spaces=None, wavefunction_terms=None, property_filter=None, filter_spaces=None): 

Determines which states need to be coupled at which levels of correction to handle the PT

• :returns: _

get_coupled_space(self, input_state_space, degenerate_space, use_second_deg, allow_PT_degs=True, wavefunction_terms=None, spaces=None, property_filter=None, filter_spaces=None): 

Applies the VPT equations semi-symbolically, dispatching based on how many degeneracies we need to handle

• :returns: _

get_nondeg_coupled_space(self, input_state_space, degenerate_space=None, spaces=None, wavefunction_terms=None, property_filter=None, filter_spaces=None): 

Applies the non-degenerate equations in semi-symbolic form to determine which states needs to be calculated. This will always be the initial input to a calculation and then certain additional states may be calculated on the fly if they are needed to handle truly degenerate stuff. The only difference there will be to add on

• input_state_space: BasisStateSpace

• degenerate_space: BasisStateSpace

• spaces: Any

• wavefunction_terms: None | Iterable[Iterable[int]]

  which terms to include when calculating corrections

• property_filter: None | Iterable[Iterable[int], Iterable[Iterable[int]]]

  a set of states and selection rules to allow for being targeted in state to calculate

• :returns: _

get_corrections(self, non_zero_cutoff=None, handle_strong_couplings=None, check_overlap=None): 

Applies the perturbation theory equations to obtain corrections to the wave functions and energies

• :returns: _

@property
high_frequency_modes(self): 

identify_strong_couplings(self, corrs): 

construct_strong_coupling_spaces(self, spec, sc, corrs, states, threshold): 

apply_VPT_equations(self, state_index, degenerate_space_indices, degenerate_energies, zero_order_state, degenerate_subspace, degenerate_subsubspace, perturbations=None, allow_PT_degs=None, ignore_odd_orders=None, intermediate_normalization=None, non_zero_cutoff=None): 

Applies VPT equations, dispatching based on how many degeneracies we need to handle

• state_index: int

  the index of the primary state being treated using the PT

• degenerate_space_indices: np.ndarray[int]

  the indices corresponding to degeneracies with the primary state in the zero-order picture

• degenerate_energies: Iterable[float | None]

  the first and (possibly) second order correction to the energies

• zero_order_states: np.ndarray[float]

  the vector for the proper zero-order state corresponding ot state_index

• degenerate_subsubspace: tuple[np.ndarray[float], np.ndarray[int]]

  the set of vectors for the zero-order states in the secondary degenerate subspace

• non_zero_cutoff: float

  cutoff for when a term can be called zero for performance reasons

• :returns: _

apply_VPT_nondeg_equations(self, state_index, deg_group, perturbations=None, non_zero_cutoff=None, check_overlap=None, intermediate_normalization=False, ignore_odd_orders=False): 

Does the dirty work of doing the VPT iterative equations.

• :returns: _

apply_VPT_2k1_rules(self, existing_corrs, perturbations=None): 

Apply expressions allowing for obtaining higher-order corrections to the energies from lower-order corrections to the wavefunctions

• existing_corrs: Any

• perturbations: Any

• :returns: _

apply_post_PT_variational_calc(self, degenerate_states, corrs): 

Applies degenerate perturbation theory by building a representation for the degenerate terms in the Hamiltonian. This is then diagonalized, allowing the degenerate states to be expressed in the basis of non-degenerate states

• H: Iterable[SparseArray]

• corrs: PerturbationTheoryCorrections

  the standard PerturbationTheory Corrections object that comes out of the application of non-deg PT

• degenerate_states: Any

  population of degenerate states

• logger: Logger

• :returns: _

drop_deg_pert_els(self, perts, deg_groups): 

• perts: Any

• deg_groups: Any

• :returns: _