def load_wavepacket(self, timestep, blockid=0, key=("q","p","Q","P","S")):
r"""Load a wavepacket at a given timestep and return a fully configured instance.
This method just calls some other :py:class:`IOManager` methods in the correct
order. It is included only for convenience and is not particularly efficient.
:param timestep: The timestep :math:`n` at which we load the wavepacket.
:param key: Specify which parameters to save. All are independent.
:type key: Tuple of valid identifier strings that are ``q``, ``p``, ``Q``, ``P``, ``S`` and ``adQ``.
Default is ``("q", "p", "Q", "P", "S")``.
:param blockid: The ID of the data block to operate on.
:return: A :py:class:`HagedornWavepacket` instance.
"""
from BlockFactory import BlockFactory
BF = BlockFactory()
descr = self.load_wavepacket_description(blockid=blockid)
HAWP = BF.create_wavepacket(descr)
# Parameters and coefficients
Pi = self.load_wavepacket_parameters(timestep=timestep, blockid=blockid, key=key)
hashes, coeffs = self.load_wavepacket_coefficients(timestep=timestep, get_hashes=True, blockid=blockid)
# Basis shapes
Ks = []
for ahash in hashes:
K_descr = self.load_wavepacket_basisshapes(the_hash=ahash, blockid=blockid)
Ks.append(BF.create_basis_shape(K_descr))
# Configure the wavepacket
HAWP.set_parameters(Pi, key=key)
HAWP.set_basis_shapes(Ks)
HAWP.set_coefficients(coeffs)
return HAWP
def load_wavepacket_inhomogeneous(iom, timestep, blockid=0):
r"""Utility function to load an inhomogeneous
wavepacket from an :py:class:`IOManager` instance.
:param iom: The :py:class:`IOManager` instance from which to load data.
:param timestep: Load the data corresponding to the given `timestep`.
:param blockid: The `datablock` from which to read the data.
Default is the block with `blockid=0`.
Note: This function is a pure utility function and is not efficient. It is
built for interactive use only and should not be use in scripts.
"""
if not iom.has_inhomogwavepacket(blockid=blockid):
print("There is no (inhomogeneous) wavepacket to load in block "+str(blockid))
return
BF = BlockFactory()
wpd = iom.load_inhomogwavepacket_description(blockid=blockid)
HAWP = BF.create_wavepacket(wpd)
# Basis shapes
BS_descr = iom.load_inhomogwavepacket_basisshapes(blockid=blockid)
BS = {}
for ahash, descr in BS_descr.iteritems():
BS[ahash] = BF.create_basis_shape(descr)
KEY = ("q","p","Q","P","S","adQ")
# Retrieve simulation data
params = iom.load_inhomogwavepacket_parameters(timestep=timestep, blockid=blockid, key=KEY)
hashes, coeffs = iom.load_inhomogwavepacket_coefficients(timestep=timestep, get_hashes=True, blockid=blockid)
# Configure the wavepacket
HAWP.set_parameters(params, key=KEY)
HAWP.set_basis_shapes([ BS[int(ha)] for ha in hashes ])
HAWP.set_coefficients(coeffs)
return HAWP
