def read_data_inhomogeneous(iom, blockid=0): r""" :param iom: An :py:class:`IOManager` instance providing the simulation data. :param blockid: The data block from which the values are read. """ BF = BlockFactory() parameters = iom.load_parameters() timegrid = iom.load_inhomogwavepacket_timegrid(blockid=blockid) # Basis shapes bsdescr = iom.load_inhomogwavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in bsdescr.iteritems(): BS[ahash] = BF.create_basis_shape(descr) # Plot the coefficients for all timesteps for j, step in enumerate(timegrid): hashes, coeffs = iom.load_inhomogwavepacket_coefficients(timestep=step, blockid=blockid, get_hashes=True) k = [] for i in xrange(parameters["ncomponents"]): bs = BS[int(hashes[i])] ki = array([bs[node] for node in bs.get_node_iterator()]) k.append(ki) plot_coefficients(k, coeffs, step, parameters["dt"], index=blockid)
def read_data_inhomogeneous(iom, blockid=0, timerange=None, path='.'): r""" :param iom: An :py:class:`IOManager` instance providing the simulation data. :param blockid: The data block from which the values are read. """ BF = BlockFactory() if iom.has_parameters(): parameters = iom.load_parameters() if "dt" in parameters: dt = parameters["dt"] else: dt = None timegrid = iom.load_inhomogwavepacket_timegrid(blockid=blockid) if timerange is not None: if len(timerange) == 1: I = (timegrid == timerange) else: I = ((timegrid >= timerange[0]) & (timegrid <= timerange[1])) if any(I): timegrid = timegrid[I] else: raise ValueError("No valid timestep remains!") # Basis shapes bsdescr = iom.load_inhomogwavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in bsdescr.items(): BS[ahash] = BF.create_basis_shape(descr) # Plot the coefficients for all timesteps for j, step in enumerate(timegrid): allhashes, allcoeffs = iom.load_inhomogwavepacket_coefficients( timestep=step, blockid=blockid, get_hashes=True) k = [] ck = [] for ahash, coeffs in zip(allhashes, allcoeffs): bs = BS[int(ahash)] ki = array([bs[node] for node in bs.get_node_iterator(mode="mag")]) ck.append(coeffs[ki]) ki.sort() k.append(ki) plot_coefficients(k, ck, step, dt, blockid=blockid, path=path)
def read_data_inhomogeneous(iom, blockid=0, timerange=None, path='.'): r""" :param iom: An :py:class:`IOManager` instance providing the simulation data. :param blockid: The data block from which the values are read. """ BF = BlockFactory() parameters = iom.load_parameters() timegrid = iom.load_inhomogwavepacket_timegrid(blockid=blockid) if timerange is not None: if len(timerange) == 1: I = (timegrid == timerange) else: I = ((timegrid >= timerange[0]) & (timegrid <= timerange[1])) if any(I): timegrid = timegrid[I] else: raise ValueError("No valid timestep remains!") # Basis shapes bsdescr = iom.load_inhomogwavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in bsdescr.items(): BS[ahash] = BF.create_basis_shape(descr) # Plot the coefficients for all timesteps for j, step in enumerate(timegrid): allhashes, allcoeffs = iom.load_inhomogwavepacket_coefficients(timestep=step, blockid=blockid, get_hashes=True) k = [] ck = [] for ahash, coeffs in zip(allhashes, allcoeffs): bs = BS[int(ahash)] ki = array([bs[node] for node in bs.get_node_iterator(mode="mag")]) ck.append(coeffs[ki]) ki.sort() k.append(ki) dt = parameters["dt"] if "dt" in parameters else None plot_coefficients(k, ck, step, dt, blockid=blockid, path=path)
def compute_energy_inhawp(iom, blockid=0, eigentrafo=True, iseigen=True): """Compute the energies of a wavepacket timeseries. This function is for inhomogeneous wavepackets. :param iom: An :py:class:`IOManager` instance providing the simulation data. :param blockid: The data block from which the values are read. :type blockid: Integer, Default is ``0`` :param eigentrafo: Whether to make a transformation into the eigenbasis. :type eigentrafo: Boolean, default is ``True``. :param iseigen: Whether the data is assumed to be in the eigenbasis. :type iseigen: Boolean, default is ``True`` """ parameters = iom.load_parameters() BF = BlockFactory() # Number of time steps we saved timesteps = iom.load_inhomogwavepacket_timegrid(blockid=blockid) nrtimesteps = timesteps.shape[0] # The potential used Potential = BF.create_potential(parameters) # Basis transformator if eigentrafo is True: BT = BasisTransformationHAWP(Potential) # We want to save energies, thus add a data slot to the data file iom.add_energy(parameters, timeslots=nrtimesteps, blockid=blockid) # Initialize a Hagedorn wavepacket with the data descr = iom.load_inhomogwavepacket_description(blockid=blockid) HAWP = BF.create_wavepacket(descr) # Inner product if HAWP.get_innerproduct() is None: IP = BF.create_inner_product(parameters["innerproduct"]) HAWP.set_innerproduct(IP) if eigentrafo is True: BT.set_matrix_builder(HAWP.get_innerproduct()) # Basis shapes BS_descr = iom.load_inhomogwavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.items(): BS[ahash] = BF.create_basis_shape(descr) O = ObservablesHAWP() KEY = ("q", "p", "Q", "P", "S", "adQ") # Iterate over all timesteps for i, step in enumerate(timesteps): print(" Computing energies of timestep %d" % step) # Retrieve simulation data params = iom.load_inhomogwavepacket_parameters(timestep=step, blockid=blockid, key=KEY) hashes, coeffs = iom.load_inhomogwavepacket_coefficients( timestep=step, 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) # Transform to the eigenbasis. if eigentrafo is True: BT.transform_to_eigen(HAWP) # Compute the energies O.set_innerproduct(HAWP.get_innerproduct()) O.set_gradient(HAWP.get_gradient_operator()) ekin = O.kinetic_energy(HAWP) if iseigen is True: epot = O.potential_energy(HAWP, Potential.evaluate_eigenvalues_at) else: epot = O.potential_energy(HAWP, Potential.evaluate_at) iom.save_energy((ekin, epot), timestep=step, blockid=blockid)
def compute_autocorrelation_inhawp(iom, obsconfig, blockid=0, eigentrafo=True): """Compute the autocorrelation of a wavepacket timeseries. This function is for inhomogeneous wavepackets. :param iom: An :py:class:`IOManager` instance providing the simulation data. :param obsconfig: Configuration parameters describing f.e. the inner product to use. :type obsconfig: A :py:class:`ParameterProvider` instance. :param blockid: The data block from which the values are read. :type blockid: Integer, Default is ``0`` :param eigentrafo: Whether to make a transformation into the eigenbasis. :type eigentrafo: Boolean, default is ``True``. """ parameters = iom.load_parameters() BF = BlockFactory() # Number of time steps we saved timesteps = iom.load_inhomogwavepacket_timegrid(blockid=blockid) nrtimesteps = timesteps.shape[0] # Basis transformator if eigentrafo is True: # The potential used Potential = BF.create_potential(parameters) BT = BasisTransformationHAWP(Potential) # We want to save autocorrelations, thus add a data slot to the data file iom.add_autocorrelation(parameters, timeslots=nrtimesteps, blockid=blockid) # Initialize a Hagedorn wavepacket with the data descr = iom.load_inhomogwavepacket_description(blockid=blockid) HAWPo = BF.create_wavepacket(descr) HAWPt = BF.create_wavepacket(descr) if eigentrafo is True: BT.set_matrix_builder(HAWPo.get_innerproduct()) # Basis shapes BS_descr = iom.load_inhomogwavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.items(): BS[ahash] = BF.create_basis_shape(descr) # Comfigure the original wavepacket # Retrieve simulation data params = iom.load_inhomogwavepacket_parameters(timestep=0, blockid=blockid) hashes, coeffs = iom.load_inhomogwavepacket_coefficients(timestep=0, get_hashes=True, blockid=blockid) # Configure the wavepacket HAWPo.set_parameters(params) HAWPo.set_basis_shapes([BS[int(ha)] for ha in hashes]) HAWPo.set_coefficients(coeffs) # Set up the innerproduct for solving the integrals <phi_0 | phi_t> IP = BF.create_inner_product(obsconfig["innerproduct"]) # Iterate over all timesteps for i, step in enumerate(timesteps): print(" Computing autocorrelations of timestep %d" % step) # Retrieve simulation data params = iom.load_inhomogwavepacket_parameters(timestep=step, blockid=blockid) hashes, coeffs = iom.load_inhomogwavepacket_coefficients(timestep=step, get_hashes=True, blockid=blockid) # Configure the wavepacket HAWPt.set_parameters(params) HAWPt.set_basis_shapes([BS[int(ha)] for ha in hashes]) HAWPt.set_coefficients(coeffs) # Transform to the eigenbasis. if eigentrafo is True: BT.transform_to_eigen(HAWPt) # Measure autocorrelations in the eigenbasis acs = IP.quadrature(HAWPo, HAWPt, diagonal=True) # Save the autocorrelations iom.save_autocorrelation(acs, timestep=step, blockid=blockid)
def compute_autocorrelation_hawp(iom, obsconfig, blockid=0, eigentrafo=True): """Compute the autocorrelation of a wavepacket timeseries. :param iom: An :py:class:`IOManager` instance providing the simulation data. :param obsconfig: Configuration parameters describing f.e. the inner product to use. :type obsconfig: A :py:class:`ParameterProvider` instance. :param blockid: The data block from which the values are read. :type blockid: Integer, Default is ``0`` :param eigentrafo: Whether to make a transformation into the eigenbasis. :type eigentrafo: Boolean, default is ``True``. """ parameters = iom.load_parameters() BF = BlockFactory() # Number of time steps we saved timesteps = iom.load_wavepacket_timegrid(blockid=blockid) nrtimesteps = timesteps.shape[0] # Basis transformator if eigentrafo is True: # The potential used Potential = BF.create_potential(parameters) BT = BasisTransformationHAWP(Potential) # We want to save norms, thus add a data slot to the data file iom.add_autocorrelation(parameters, timeslots=nrtimesteps, blockid=blockid) # Initialize a Hagedorn wavepacket with the data descr = iom.load_wavepacket_description(blockid=blockid) HAWPo = BF.create_wavepacket(descr) HAWPt = BF.create_wavepacket(descr) if eigentrafo is True: BT.set_matrix_builder(HAWPo.get_innerproduct()) # Basis shapes BS_descr = iom.load_wavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.items(): BS[ahash] = BF.create_basis_shape(descr) # Comfigure the original wavepacket KEY = ("q", "p", "Q", "P", "S", "adQ") # Retrieve simulation data params = iom.load_wavepacket_parameters(timestep=0, blockid=blockid, key=KEY) hashes, coeffs = iom.load_wavepacket_coefficients(timestep=0, get_hashes=True, blockid=blockid) # Configure the wavepacket HAWPo.set_parameters(params, key=KEY) HAWPo.set_basis_shapes([BS[int(ha)] for ha in hashes]) HAWPo.set_coefficients(coeffs) # Set up the innerproduct for solving the integrals <phi_0 | phi_t> IP = BF.create_inner_product(obsconfig["innerproduct"]) # Transform to the eigenbasis. if eigentrafo is True: BT.transform_to_eigen(HAWPo) # Iterate over all timesteps for i, step in enumerate(timesteps): print(" Computing autocorrelation of timestep %d" % step) # Retrieve simulation data paramst = iom.load_wavepacket_parameters(timestep=step, blockid=blockid, key=KEY) hashes, coeffs = iom.load_wavepacket_coefficients(timestep=step, get_hashes=True, blockid=blockid) # Configure the wavepacket HAWPt.set_parameters(paramst, key=KEY) HAWPt.set_basis_shapes([BS[int(ha)] for ha in hashes]) HAWPt.set_coefficients(coeffs) # Transform to the eigenbasis. if eigentrafo is True: BT.transform_to_eigen(HAWPt) # Measure autocorrelations in the eigenbasis acs = IP.quadrature(HAWPo, HAWPt, diagonal=True) # Save the autocorrelations iom.save_autocorrelation(acs, timestep=step, blockid=blockid)
def load_from_file(filepath, blockid=0, timestep=0, sizeK=None): r"""Utility script to load wavepacket parameters and coefficients from another simulation result in a form suitable for the input configuration of a new simulation. This is (mainly) used to start simulations with previously computed eigenstates. :param filepath: The path to the `.hdf5` file from which data will be read. :param blockid: The `datablock` from which to read the data. Default is the block with `blockid=0`. :param timestep: Load the data corresponding to the given `timestep`. The default timestep is `0`. :param sizeK: Load at most 'sizeK' many coefficients. Note that the order is defined by the linearization mapping :math:`\mu` of the packet's current basis shape. We then pick the first `sizeK` ones. """ IOM = IOManager() IOM.open_file(filepath) # Check if we have data tg = IOM.load_wavepacket_timegrid(blockid=blockid) if timestep not in tg: raise ValueError("No data for timestep {}".format(timestep)) # Load data and assemble packet BF = BlockFactory() # Basis shapes BS_descr = IOM.load_wavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.items(): BS[ahash] = BF.create_basis_shape(descr) # Create a packet wpd = IOM.load_wavepacket_description(blockid=blockid) HAWP = BF.create_wavepacket(wpd) # Data ha, ci = IOM.load_wavepacket_coefficients(blockid=blockid, timestep=timestep, get_hashes=True) Pi = IOM.load_wavepacket_parameters(blockid=blockid, timestep=timestep) HAWP.set_parameters(Pi) HAWP.set_basis_shapes([BS[int(h)] for h in ha]) HAWP.set_coefficients(ci) # Reformat data C = [] for n in range(HAWP.get_number_components()): B = HAWP.get_basis_shapes(component=n) cn = HAWP.get_coefficients(component=n) l = [] for i in range(B.get_basis_size()): l.append((B[i], cn[i, 0])) C.append(l) if sizeK is not None: # We load at most 'sizeK' coefficients. # Note that this does NOT specify which # ones in terms of multi-indices. C = [c[:sizeK] for c in C] return Pi, C
def load_from_file(filepath, blockid=0, timestep=0, sizeK=None): r"""Utility script to load wavepacket parameters and coefficients from another simulation result in a form suitable for the input configuration of a new simulation. This is (mainly) used to start simulations with previously computed eigenstates. :param filepath: The path to the `.hdf5` file from which data will be read. :param blockid: The `datablock` from which to read the data. Default is the block with `blockid=0`. :param timestep: Load the data corresponding to the given `timestep`. The default timestep is `0`. :param sizeK: Load at most 'sizeK' many coefficients. Note that the order is defined by the linearization mapping :math:`\mu` of the packet's current basis shape. We then pick the first `sizeK` ones. """ IOM = IOManager() IOM.open_file(filepath) # Check if we have data tg = IOM.load_wavepacket_timegrid(blockid=blockid) if timestep not in tg: raise ValueError("No data for timestep {}".format(timestep)) # Load data and assemble packet BF = BlockFactory() # Basis shapes BS_descr = IOM.load_wavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.items(): BS[ahash] = BF.create_basis_shape(descr) # Create a packet wpd = IOM.load_wavepacket_description(blockid=blockid) HAWP = BF.create_wavepacket(wpd) # Data ha, ci = IOM.load_wavepacket_coefficients(blockid=blockid, timestep=timestep, get_hashes=True) Pi = IOM.load_wavepacket_parameters(blockid=blockid, timestep=timestep) HAWP.set_parameters(Pi) HAWP.set_basis_shapes([BS[int(h)] for h in ha]) HAWP.set_coefficients(ci) # Reformat data C = [] for n in range(HAWP.get_number_components()): B = HAWP.get_basis_shapes(component=n) cn = HAWP.get_coefficients(component=n) l = [] for i in range(B.get_basis_size()): l.append((B[i], cn[i, 0])) C.append(l) if sizeK is not None: # We load at most 'sizeK' coefficients. # Note that this does NOT specify which # ones in terms of multi-indices. C = [c[:sizeK] for c in C] return Pi, C
def plot_frames(PP, iom, blockid=0, load=False, limits=None): r""" """ parameters = iom.load_parameters() BF = BlockFactory() if not parameters["dimension"] == 2: print("No wavepacket of two space dimensions, silent return!") return if PP is None: PP = parameters if load is True: # TODO: Implement reshaping raise NotImplementedError("Loading of 2D grids is not implemented") #G = iom.load_grid(blockid=blockid) #G = grid.reshape((1, -1)) else: G = BF.create_grid(PP) u, v = map(squeeze, G.get_axes()) V = BF.create_potential(parameters) BT = BasisTransformationHAWP(V) wpd = iom.load_wavepacket_description(blockid=blockid) HAWP = BF.create_wavepacket(wpd) # Basis shapes BS_descr = iom.load_wavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.iteritems(): BS[ahash] = BF.create_basis_shape(descr) timegrid = iom.load_wavepacket_timegrid(blockid=blockid) N = HAWP.get_number_components() for step in timegrid: print(" Plotting frame of timestep # " + str(step)) hi, ci = iom.load_wavepacket_coefficients(timestep=step, get_hashes=True, blockid=blockid) Pi = iom.load_wavepacket_parameters(timestep=step, blockid=blockid) HAWP.set_parameters(Pi) HAWP.set_basis_shapes([ BS[int(ha)] for ha in hi ]) HAWP.set_coefficients(ci) psi = HAWP.evaluate_at(G, prefactor=True, component=0) fig = figure() for level in xrange(N): z = psi[level] z = z.reshape(G.get_number_nodes()) subplot(N,1,level+1) #plotcm(z.reshape(G.get_number_nodes()), darken=0.3) plotcf2d(u, v, z, darken=0.3, limits=limits) savefig("wavepacket_block_"+str(blockid)+"_level_"+str(level)+"_timestep_"+(5-len(str(step)))*"0"+str(step)+".png") close(fig) print(" Plotting frames finished")
def compute_energy_inhawp(iom, blockid=0, eigentrafo=True, iseigen=True): """Compute the energies of a wavepacket timeseries. This function is for inhomogeneous wavepackets. :param iom: An :py:class:`IOManager` instance providing the simulation data. :param blockid: The data block from which the values are read. :type blockid: Integer, Default is ``0`` :param eigentrafo: Whether to make a transformation into the eigenbasis. :type eigentrafo: Boolean, default is ``True``. :param iseigen: Whether the data is assumed to be in the eigenbasis. :type iseigen: Boolean, default is ``True`` """ parameters = iom.load_parameters() BF = BlockFactory() # Number of time steps we saved timesteps = iom.load_inhomogwavepacket_timegrid(blockid=blockid) nrtimesteps = timesteps.shape[0] # The potential used Potential = BF.create_potential(parameters) # Basis transformator if eigentrafo is True: BT = BasisTransformationHAWP(Potential) # We want to save energies, thus add a data slot to the data file iom.add_energy(parameters, timeslots=nrtimesteps, blockid=blockid) # Initialize a Hagedorn wavepacket with the data descr = iom.load_inhomogwavepacket_description(blockid=blockid) HAWP = BF.create_wavepacket(descr) # Inner product if HAWP.get_innerproduct() is None: IP = BF.create_inner_product(parameters["innerproduct"]) HAWP.set_innerproduct(IP) if eigentrafo is True: BT.set_matrix_builder(HAWP.get_innerproduct()) # Basis shapes BS_descr = iom.load_inhomogwavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.items(): BS[ahash] = BF.create_basis_shape(descr) O = ObservablesHAWP() KEY = ("q", "p", "Q", "P", "S", "adQ") # Iterate over all timesteps for i, step in enumerate(timesteps): print(" Computing energies of timestep %d" % step) # Retrieve simulation data params = iom.load_inhomogwavepacket_parameters(timestep=step, blockid=blockid, key=KEY) hashes, coeffs = iom.load_inhomogwavepacket_coefficients(timestep=step, 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) # Transform to the eigenbasis. if eigentrafo is True: BT.transform_to_eigen(HAWP) # Compute the energies O.set_innerproduct(HAWP.get_innerproduct()) ekin = O.kinetic_energy(HAWP) if iseigen is True: epot = O.potential_energy(HAWP, Potential.evaluate_eigenvalues_at) else: epot = O.potential_energy(HAWP, Potential.evaluate_at) iom.save_energy((ekin, epot), timestep=step, blockid=blockid)