__init__(self, order=2, expansion_order=None, coupled_states=None, 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, allow_post_PT_calc=None, modify_degenerate_perturbations=None, gaussian_resonance_handling=None, ignore_odd_order_energies=None, intermediate_normalization=None, zero_element_warning=None, degenerate_states=None, handle_strong_couplings=None, strong_coupling_test_modes=None, strong_couplings_state_filter=None, strongly_coupled_group_filter=None, extend_strong_coupling_spaces=None, strong_coupling_zero_order_energy_cutoff=None, low_frequency_mode_cutoff=None, zero_order_energy_corrections=None, check_overlap=None): 

• order: int

  the order of perturbation theory to apply

• expansion_order: int | dict

  the order to go to in the expansions of the perturbations, this can be supplied for different properties independently, like

  expansion_order = {
  'potential':some_int,
  'kinetic':some_int,
  'dipole':some_int
  }
  

• degenerate_states: Iterable[BasisStateSpace]

  the set of degeneracies to handle

• coupled_states: Iterable[SelectionRuleStateSpace]

  explicit bases of states to use at each order in the perturbation theory

• total_space: Iterable[BasisStateSpace]

  the total state spaces at each order in the perturbation theory

• flat_total_space: BasisStateSpace

  the union of all of the total state spaces

• state_space_iterations: int

  the order to go to when getting the coupled_states

• state_space_terms: Iterable[(int, int)]

  the explicit set of terms to include, as a tuple (i, j) which indicates (H(i), |n(j)>)

• state_space_filters: dict

  filters that can be used to cut down on the size of bases (see VPTRunner.get_state_space_filter)

• allow_post_PT_calc: bool

  whether to do the post-perturbation theory variational calculation for degeneracy handling

• modify_degenerate_perturbations: bool

  whether to modify the perturbation representation matrices themselves when doing degeneracy handling

• gaussian_resonance_handling: bool

  whether or not to skip the post-PT variational calculation for states with more than two quanta of excitation

• ignore_odd_order_energies: bool

  whether or not to skip actually calculating the energy corrections for odd orders

• intermediate_normalization: bool

  whether or not to use ‘intermediate normalization’ in the wavefunctions

• zero_element_warning: bool

  whether or not to warn if an element of the representations evaluated to zero (i.e. we wasted effort)

• low_frequency_mode_cutoff: float (default:500 cm-1)

  the energy below which to consider a mode to be “low frequency”

• zero_order_energy_corrections: dict

  energies to use for the zero-order states instead of the diagonal of H(0)

• check_overlap: bool default:True

  whether or not to ensure states are normalized in the VPT

@staticmethod
get_zero_order_energies(corrected_fundamental_freqs, states): 

• corrected_fundamental_freqs: Any

• states: Any

• :returns: _

The basis_postfilters have multiple possible values. Here are the currently supported cases

{
    'max_quanta': [2, -1, 1, -1, ...] # the max number of quanta allowed in a given mode in the basis (-1 means infinity)
}

• for excluding transitions

{
    'excluded_transitions': [[0, 0, 1, 0, ...], [1, 0, 0, 0, ...], ...] # a set of transitions that are forbidden on the input states
}

• for excluding based on a test

{
    'test': func # a function that takes the basis and tests if states should be allowed
}