def read_data_homogeneous(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. """ parameters = iom.load_parameters() timegrid = iom.load_wavepacket_timegrid(blockid=blockid) time = timegrid * parameters["dt"] # The potential used Potential = BlockFactory().create_potential(parameters) # Basis transformator BT = BasisTransformationHAWP(Potential) # Basis shapes BS_descr = iom.load_wavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.iteritems(): BS[ahash] = BlockFactory().create_basis_shape(descr) # Initialize a Hagedorn wavepacket with the data descr = iom.load_wavepacket_description(blockid=blockid) HAWP = BlockFactory().create_wavepacket(descr) BT.set_matrix_builder(HAWP.get_quadrature()) # Store the resulting coefficients here CI = [[] for i in xrange(HAWP.get_number_components())] # Iterate over all timesteps, this is an *expensive* transformation for i, step in enumerate(timegrid): print(" Computing eigentransformation at timestep " + str(step)) # Retrieve simulation data params = iom.load_wavepacket_parameters(timestep=step, blockid=blockid) hashes, coeffs = iom.load_wavepacket_coefficients(timestep=step, get_hashes=True, blockid=blockid) # Configure the wavepacket HAWP.set_parameters(params) HAWP.set_basis_shape([BS[int(ha)] for ha in hashes]) HAWP.set_coefficients(coeffs) # Transform to the eigenbasis. BT.transform_to_eigen(HAWP) for index, item in enumerate(HAWP.get_coefficients()): CI[index].append(item) CI = [transpose(hstack(item)) for item in CI] return time, CI
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. """ parameters = iom.load_parameters() timegrid = iom.load_inhomogwavepacket_timegrid(blockid=blockid) time = timegrid * parameters["dt"] # The potential used Potential = BlockFactory().create_potential(parameters) # Basis transformator BT = BasisTransformationHAWP(Potential) # Basis shapes BS_descr = iom.load_wavepacket_basisshapes(blockid=blockid) BS = {} for ahash, descr in BS_descr.iteritems(): BS[ahash] = BlockFactory().create_basis_shape(descr) # Initialize a Hagedorn wavepacket with the data descr = iom.load_inhomogwavepacket_description(blockid=blockid) HAWP = BlockFactory().create_wavepacket(descr) BT.set_matrix_builder(HAWP.get_quadrature()) # Store the resulting coefficients here CI = [ [] for i in xrange(HAWP.get_number_components()) ] # Iterate over all timesteps, this is an *expensive* transformation for i, step in enumerate(timegrid): print(" Computing eigentransformation at timestep "+str(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 HAWP.set_parameters(params) HAWP.set_basis_shapes([ BS[int(ha)] for ha in hashes ]) HAWP.set_coefficients(coeffs) # Transform to the eigenbasis. BT.transform_to_eigen(HAWP) for index, item in enumerate(HAWP.get_coefficients()): CI[index].append(item) CI = [ transpose(hstack(item)) for item in CI ] return time, CI
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. """ parameters = iom.load_parameters() timegrid = iom.load_inhomogwavepacket_timegrid(blockid=blockid) dt = parameters["dt"] if "dt" in parameters else 1.0 time = timegrid * dt # The potential used Potential = BlockFactory().create_potential(parameters) # Basis transformator BT = BasisTransformationHAWP(Potential) # Initialize a Hagedorn wavepacket with the data descr = iom.load_inhomogwavepacket_description(blockid=blockid) HAWP = BlockFactory().create_wavepacket(descr) BT.set_matrix_builder(HAWP.get_quadrature()) # Store the resulting coefficients here CI = [[] for i in range(HAWP.get_number_components())] # Iterate over all timesteps, this is an *expensive* transformation for i, step in enumerate(timegrid): print(" Computing eigentransformation at timestep {}".format(step)) # Retrieve simulation data HAWP = iom.load_inhomogwavepacket(timestep=step, blockid=blockid) # Transform to the eigenbasis. BT.transform_to_eigen(HAWP) for index, item in enumerate(HAWP.get_coefficients()): CI[index].append(item) CI = [transpose(hstack(item)) for item in CI] return time, CI
def compute_energy(iom, blockid=0, eigentrafo=True, iseigen=True): """ :param iom: An :py:class:`IOManager: instance providing the simulation data. :param blockid: The data block from which the values are read. 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() # Number of time steps we saved timesteps = iom.load_wavefunction_timegrid(blockid=blockid) nrtimesteps = timesteps.shape[0] # Construct grid from the parameters grid = BlockFactory().create_grid(parameters) # The potential used Potential = BlockFactory().create_potential(parameters) # The operators KO = KineticOperator(grid) KO.calculate_operator(parameters["eps"]) opT = KO if eigentrafo is True: opV = Potential.evaluate_at(grid) else: if iseigen is True: opV = Potential.evaluate_eigenvalues_at(grid, as_matrix=True) else: opV = Potential.evaluate_at(grid, as_matrix=True) # Basis transformator if eigentrafo is True: BT = BasisTransformationWF(Potential) BT.set_grid(grid) # And two empty wavefunctions WF = WaveFunction(parameters) WF.set_grid(grid) WF2 = WaveFunction(parameters) WF2.set_grid(grid) # We want to save norms, thus add a data slot to the data file iom.add_energy(parameters, timeslots=nrtimesteps, blockid=blockid) nst = Potential.get_number_components() if eigentrafo is True: # Iterate over all timesteps for i, step in enumerate(timesteps): print(" Computing energies of timestep # " + str(step)) # Retrieve simulation data values = iom.load_wavefunction(timestep=step, blockid=blockid) values = [ values[j,...] for j in xrange(parameters["ncomponents"]) ] WF.set_values(values) # Project wavefunction values to eigenbasis BT.transform_to_eigen(WF) ekinlist = [] epotlist = [] # For each component of |Psi> values = WF.get_values() for index, item in enumerate(values): # tmp is the Vector (0, 0, 0, \psi_i, 0, 0, ...) tmp = [ zeros(item.shape) for z in xrange(nst) ] tmp[index] = item WF2.set_values(tmp) # Project this vector to the canonical basis BT.transform_to_canonical(WF2) # And calculate the energies of these components ekinlist.append(WF2.kinetic_energy(opT, summed=True)) epotlist.append(WF2.potential_energy(opV, summed=True)) iom.save_energy((ekinlist, epotlist), timestep=step, blockid=blockid) else: # Iterate over all timesteps for i, step in enumerate(timesteps): print(" Computing energies of timestep # " + str(step)) # Retrieve simulation data values = iom.load_wavefunction(timestep=step, blockid=blockid) values = [ values[j,...] for j in xrange(parameters["ncomponents"]) ] WF.set_values(values) # And calculate the energies of these components ekinlist = WF.kinetic_energy(opT, summed=False) epotlist = WF.potential_energy(opV, summed=False) iom.save_energy((ekinlist, epotlist), timestep=step, blockid=blockid)
def compute_energy(iom, blockid=0, eigentrafo=True, iseigen=True): """ :param iom: An :py:class:`IOManager: instance providing the simulation data. :param blockid: The data block from which the values are read. 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() # Number of time steps we saved timesteps = iom.load_wavefunction_timegrid(blockid=blockid) nrtimesteps = timesteps.shape[0] # Construct grid from the parameters grid = BlockFactory().create_grid(parameters) # The potential used Potential = BlockFactory().create_potential(parameters) # The operators KO = KineticOperator(grid) KO.calculate_operator(parameters["eps"]) opT = KO if eigentrafo is True: opV = Potential.evaluate_at(grid) else: if iseigen is True: opV = Potential.evaluate_eigenvalues_at(grid, as_matrix=True) else: opV = Potential.evaluate_at(grid, as_matrix=True) # Basis transformator if eigentrafo is True: BT = BasisTransformationWF(Potential) BT.set_grid(grid) # And two empty wavefunctions WF = WaveFunction(parameters) WF.set_grid(grid) WF2 = WaveFunction(parameters) WF2.set_grid(grid) # We want to save norms, thus add a data slot to the data file iom.add_energy(parameters, timeslots=nrtimesteps, blockid=blockid) nst = Potential.get_number_components() if eigentrafo is True: # Iterate over all timesteps for i, step in enumerate(timesteps): print(" Computing energies of timestep # " + str(step)) # Retrieve simulation data values = iom.load_wavefunction(timestep=step, blockid=blockid) values = [ values[j, ...] for j in xrange(parameters["ncomponents"]) ] WF.set_values(values) # Project wavefunction values to eigenbasis BT.transform_to_eigen(WF) ekinlist = [] epotlist = [] # For each component of |Psi> values = WF.get_values() for index, item in enumerate(values): # tmp is the Vector (0, 0, 0, \psi_i, 0, 0, ...) tmp = [zeros(item.shape) for z in xrange(nst)] tmp[index] = item WF2.set_values(tmp) # Project this vector to the canonical basis BT.transform_to_canonical(WF2) # And calculate the energies of these components ekinlist.append(WF2.kinetic_energy(opT, summed=True)) epotlist.append(WF2.potential_energy(opV, summed=True)) iom.save_energy((ekinlist, epotlist), timestep=step, blockid=blockid) else: # Iterate over all timesteps for i, step in enumerate(timesteps): print(" Computing energies of timestep # " + str(step)) # Retrieve simulation data values = iom.load_wavefunction(timestep=step, blockid=blockid) values = [ values[j, ...] for j in xrange(parameters["ncomponents"]) ] WF.set_values(values) # And calculate the energies of these components ekinlist = WF.kinetic_energy(opT, summed=False) epotlist = WF.potential_energy(opV, summed=False) iom.save_energy((ekinlist, epotlist), timestep=step, blockid=blockid)