def state_diffdm(method, ground_state, amplitude, intermediates=None):
"""
Compute the one-particle difference density matrix of an excited state
in the MO basis.
Parameters
----------
method : str, AdcMethod
The method to use for the computation (e.g. "adc2")
ground_state : LazyMp
The ground state upon which the excitation was based
amplitude : AmplitudeVector
The amplitude vector
intermediates : adcc.Intermediates
Intermediates from the ADC calculation to reuse
"""
if not isinstance(method, AdcMethod):
method = AdcMethod(method)
if not isinstance(ground_state, LazyMp):
raise TypeError("ground_state should be a LazyMp object.")
if not isinstance(amplitude, AmplitudeVector):
raise TypeError("amplitude should be an AmplitudeVector object.")
if intermediates is None:
intermediates = Intermediates(ground_state)
if method.name not in DISPATCH:
raise NotImplementedError("state_diffdm is not implemented "
f"for {method.name}.")
else:
ret = DISPATCH[method.name](ground_state, amplitude, intermediates)
return ret.evaluate()
def modified_transition_moments(method,
ground_state,
dipole_operator=None,
intermediates=None):
"""Compute the modified transition moments (MTM) for the provided
ADC method with reference to the passed ground state.
Parameters
----------
method: adc.Method
Provide a method at which to compute the MTMs
ground_state : adcc.LazyMp
The MP ground state
dipole_operator : adcc.OneParticleOperator or list, optional
Only required if different dipole operators than the standard
dipole operators in the MO basis should be used.
intermediates : adcc.Intermediates
Intermediates from the ADC calculation to reuse
Returns
-------
adcc.AmplitudeVector or list of adcc.AmplitudeVector
"""
if not isinstance(method, AdcMethod):
method = AdcMethod(method)
if not isinstance(ground_state, LazyMp):
raise TypeError("ground_state should be a LazyMp object.")
if intermediates is None:
intermediates = Intermediates(ground_state)
unpack = False
if dipole_operator is None:
dipole_operator = ground_state.reference_state.operators.electric_dipole
elif not isinstance(dipole_operator, list):
unpack = True
dipole_operator = [dipole_operator]
if method.name not in DISPATCH:
raise NotImplementedError("modified_transition_moments is not "
f"implemented for {method.name}.")
ret = [
DISPATCH[method.name](ground_state, dipop, intermediates)
for dipop in dipole_operator
]
if unpack:
assert len(ret) == 1
ret = ret[0]
return evaluate(ret)
def state2state_transition_dm(method,
ground_state,
amplitude_from,
amplitude_to,
intermediates=None):
"""
Compute the state to state transition density matrix
state in the MO basis using the intermediate-states representation.
Parameters
----------
method : str, AdcMethod
The method to use for the computation (e.g. "adc2")
ground_state : LazyMp
The ground state upon which the excitation was based
amplitude_from : AmplitudeVector
The amplitude vector of the state to start from
amplitude_to : AmplitudeVector
The amplitude vector of the state to excite to
intermediates : adcc.Intermediates
Intermediates from the ADC calculation to reuse
"""
if not isinstance(method, AdcMethod):
method = AdcMethod(method)
if not isinstance(ground_state, LazyMp):
raise TypeError("ground_state should be a LazyMp object.")
if not isinstance(amplitude_from, AmplitudeVector):
raise TypeError("amplitude_from should be an AmplitudeVector object.")
if not isinstance(amplitude_to, AmplitudeVector):
raise TypeError("amplitude_to should be an AmplitudeVector object.")
if intermediates is None:
intermediates = Intermediates(ground_state)
if method.name not in DISPATCH:
raise NotImplementedError(
"state2state_transition_dm is not implemented "
f"for {method.name}.")
else:
# final state is on the bra side/left (complex conjugate)
# see ref https://doi.org/10.1080/00268976.2013.859313, appendix A2
ret = DISPATCH[method.name](ground_state, amplitude_to, amplitude_from,
intermediates)
return ret.evaluate()
def state2state_transition_dm(method, ground_state, amplitude_from,
amplitude_to, intermediates=None):
"""
Compute the state to state transition density matrix
state in the MO basis using the intermediate-states representation.
Parameters
----------
method : str, AdcMethod
The method to use for the computation (e.g. "adc2")
ground_state : LazyMp
The ground state upon which the excitation was based
amplitude_from : AmplitudeVector
The amplitude vector of the state to start from
amplitude_to : AmplitudeVector
The amplitude vector of the state to excite to
intermediates : AdcIntermediates
Intermediates from the ADC calculation to reuse
"""
if not isinstance(method, AdcMethod):
method = AdcMethod(method)
if not isinstance(ground_state, libadcc.LazyMp):
raise TypeError("ground_state should be a LazyMp object.")
if not isinstance(amplitude_from, AmplitudeVector):
raise TypeError("amplitude_from should be an AmplitudeVector object.")
if not isinstance(amplitude_to, AmplitudeVector):
raise TypeError("amplitude_to should be an AmplitudeVector object.")
if intermediates is None:
intermediates = libadcc.AdcIntermediates(ground_state)
if method.name not in DISPATCH:
raise NotImplementedError("state2state_transition_dm is not implemented "
f"for {method.name}.")
else:
ret = DISPATCH[method.name](ground_state, amplitude_from, amplitude_to,
intermediates)
return ret.evaluate()