def prepare_simulation(self):
r"""Set up a Fourier propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise: :py:class:`ValueError` For invalid or missing input data.
"""
# The potential instance
potential = BlockFactory().create_potential(self.parameters)
# Compute the position space grid points
grid = BlockFactory().create_grid(self.parameters)
# Construct initial values
I = Initializer(self.parameters)
initialvalues = I.initialize_for_fourier(grid)
# Transform the initial values to the canonical basis
BT = BasisTransformationWF(potential)
BT.set_grid(grid)
BT.transform_to_canonical(initialvalues)
# Finally create and initialize the propagator instance
self.propagator = FourierPropagator(potential, initialvalues, self.parameters)
# Write some initial values to disk
slots = self._tm.compute_number_saves()
self.IOManager.add_grid(self.parameters, blockid="global")
self.IOManager.add_fourieroperators(self.parameters)
self.IOManager.add_wavefunction(self.parameters, timeslots=slots)
self.IOManager.save_grid(grid.get_nodes(flat=True), blockid="global")
self.IOManager.save_fourieroperators(self.propagator.get_operators())
self.IOManager.save_wavefunction(initialvalues.get_values(), timestep=0)
def prepare_simulation(self):
r"""Set up a Fourier propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise ValueError: For invalid or missing input data.
"""
# The potential instance
potential = BlockFactory().create_potential(self.parameters)
# Compute the position space grid points
grid = BlockFactory().create_grid(self.parameters)
# Construct initial values
I = Initializer(self.parameters)
initialvalues = I.initialize_for_fourier(grid)
# Transform the initial values to the canonical basis
BT = BasisTransformationWF(potential)
BT.set_grid(grid)
BT.transform_to_canonical(initialvalues)
# Finally create and initialize the propagator instace
self.propagator = FourierPropagator(potential, initialvalues,
self.parameters)
# Write some initial values to disk
slots = self._tm.compute_number_saves()
self.IOManager.add_grid(self.parameters, blockid="global")
self.IOManager.add_fourieroperators(self.parameters)
self.IOManager.add_wavefunction(self.parameters, timeslots=slots)
self.IOManager.save_grid(grid.get_nodes(flat=False), blockid="global")
self.IOManager.save_fourieroperators(self.propagator.get_operators())
self.IOManager.save_wavefunction(initialvalues.get_values(),
timestep=0)
class SimulationLoopFourier(SimulationLoop):
"""This class acts as the main simulation loop. It owns a propagator that
propagates a set of initial values during a time evolution.
"""
def __init__(self, parameters):
"""Create a new simulation loop instance for a simulation
using the Fourier propagation method.
:param parameters: The simulation parameters.
:type parameters: A :py:class:`ParameterProvider` instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
# The time propagator instance driving the simulation.
self.propagator = None
# An `IOManager` instance for saving simulation results.
self.IOManager = None
# Which data do we want to save
self._tm = self.parameters.get_timemanager()
# Set up serialization of simulation data
self.IOManager = IOManager()
self.IOManager.create_file()
self.IOManager.create_block()
# Save the simulation parameters
self.IOManager.add_parameters()
self.IOManager.save_parameters(parameters)
def prepare_simulation(self):
r"""Set up a Fourier propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise: :py:class:`ValueError` For invalid or missing input data.
"""
# The potential instance
potential = BlockFactory().create_potential(self.parameters)
# Compute the position space grid points
grid = BlockFactory().create_grid(self.parameters)
# Construct initial values
I = Initializer(self.parameters)
initialvalues = I.initialize_for_fourier(grid)
# Transform the initial values to the canonical basis
BT = BasisTransformationWF(potential)
BT.set_grid(grid)
BT.transform_to_canonical(initialvalues)
# Finally create and initialize the propagator instance
self.propagator = FourierPropagator(potential, initialvalues, self.parameters)
# Write some initial values to disk
slots = self._tm.compute_number_saves()
self.IOManager.add_grid(self.parameters, blockid="global")
self.IOManager.add_fourieroperators(self.parameters)
self.IOManager.add_wavefunction(self.parameters, timeslots=slots)
self.IOManager.save_grid(grid.get_nodes(flat=True), blockid="global")
self.IOManager.save_fourieroperators(self.propagator.get_operators())
self.IOManager.save_wavefunction(initialvalues.get_values(), timestep=0)
def run_simulation(self):
r"""Run the simulation loop for a number of time steps.
"""
# The number of time steps we will perform.
nsteps = self._tm.compute_number_timesteps()
# Run the prepropagate step
self.propagator.pre_propagate()
# Note: We do not save any data here
# Run the simulation for a given number of timesteps
for i in xrange(1, nsteps+1):
print(" doing timestep "+str(i))
self.propagator.propagate()
# Save some simulation data
if self._tm.must_save(i):
# Run the postpropagate step
self.propagator.post_propagate()
self.IOManager.save_wavefunction(self.propagator.get_wavefunction().get_values(), timestep=i)
# Run the prepropagate step
self.propagator.pre_propagate()
# Run the postpropagate step
self.propagator.post_propagate()
# Note: We do not save any data here
def end_simulation(self):
"""Do the necessary cleanup after a simulation. For example request the
:py:class:`IOManager` to write the data and close the output files.
"""
self.IOManager.finalize()
class SimulationLoopFourier(SimulationLoop):
"""This class acts as the main simulation loop. It owns a propagator that
propagates a set of initial values during a time evolution.
"""
def __init__(self, parameters):
"""Create a new simulation loop instance for a simulation
using the Fourier propagation method.
:param parameters: The simulation parameters.
:type parameters: A :py:class:`ParameterProvider` instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
# The time propagator instance driving the simulation.
self.propagator = None
# An `IOManager` instance for saving simulation results.
self.IOManager = None
# Which data do we want to save
self._tm = self.parameters.get_timemanager()
# Set up serialization of simulation data
self.IOManager = IOManager()
self.IOManager.create_file(self.parameters)
self.IOManager.create_block()
def prepare_simulation(self):
r"""Set up a Fourier propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise ValueError: For invalid or missing input data.
"""
# The potential instance
potential = BlockFactory().create_potential(self.parameters)
# Compute the position space grid points
grid = BlockFactory().create_grid(self.parameters)
# Construct initial values
I = Initializer(self.parameters)
initialvalues = I.initialize_for_fourier(grid)
# Transform the initial values to the canonical basis
BT = BasisTransformationWF(potential)
BT.set_grid(grid)
BT.transform_to_canonical(initialvalues)
# Finally create and initialize the propagator instace
self.propagator = FourierPropagator(potential, initialvalues,
self.parameters)
# Write some initial values to disk
slots = self._tm.compute_number_saves()
self.IOManager.add_grid(self.parameters, blockid="global")
self.IOManager.add_fourieroperators(self.parameters)
self.IOManager.add_wavefunction(self.parameters, timeslots=slots)
self.IOManager.save_grid(grid.get_nodes(flat=False), blockid="global")
self.IOManager.save_fourieroperators(self.propagator.get_operators())
self.IOManager.save_wavefunction(initialvalues.get_values(),
timestep=0)
def run_simulation(self):
r"""Run the simulation loop for a number of time steps.
"""
# The number of time steps we will perform.
nsteps = self._tm.compute_number_timesteps()
# Run the simulation for a given number of timesteps
for i in xrange(1, nsteps + 1):
print(" doing timestep " + str(i))
self.propagator.propagate()
# Save some simulation data
if self._tm.must_save(i):
self.IOManager.save_wavefunction(
self.propagator.get_wavefunction().get_values(),
timestep=i)
def end_simulation(self):
"""Do the necessary cleanup after a simulation. For example request the
:py:class:`IOManager` to write the data and close the output files.
"""
self.IOManager.finalize()
def prepare_simulation(self):
r"""
Set up a Fourier propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise ValueError: For invalid or missing input data.
"""
# Compute the position space grid points
nodes = self.parameters["f"] * sp.pi * sp.arange(-1, 1, 2.0/self.parameters["ngn"], dtype=np.complexfloating)
# The potential instance
potential = PF().create_potential(self.parameters)
# Check for enough initial values
if not self.parameters.has_key("initial_values"):
if len(self.parameters["parameters"]) < potential.get_number_components():
raise ValueError("Too few initial states given. Parameters are missing.")
if len(self.parameters["coefficients"]) < potential.get_number_components():
raise ValueError("Too few initial states given. Coefficients are missing.")
# Calculate the initial values sampled from a hagedorn wave packet
d = dict([("ncomponents", 1), ("basis_size", self.parameters["basis_size"]), ("eps", self.parameters["eps"])])
# Initial values given in the "fourier" specific format
if self.parameters.has_key("initial_values"):
initialvalues = [ np.zeros(nodes.shape, dtype=np.complexfloating) for i in xrange(self.parameters["ncomponents"]) ]
for level, params, coeffs in self.parameters["initial_values"]:
hwp = HagedornWavepacket(d)
hwp.set_parameters(params)
for index, value in coeffs:
hwp.set_coefficient(0, index, value)
iv = hwp.evaluate_at(nodes, component=0, prefactor=True)
initialvalues[level] = initialvalues[level] + iv
# Initial value read in compatibility mode to the packet algorithms
else:
# See if we have a list of parameter tuples or just a single 5-tuple
# This is for compatibility with the inhomogeneous case.
try:
# We have a list of parameter tuples this is ok for the loop below
len(self.parameters["parameters"][0])
parameters = self.parameters["parameters"]
except TypeError:
# We have just a single 5-tuple of parameters, we need to replicate for looping
parameters = [ self.parameters["parameters"] for i in xrange(self.parameters["ncomponents"]) ]
initialvalues = []
for level, item in enumerate(parameters):
hwp = HagedornWavepacket(d)
hwp.set_parameters(item)
# Set the coefficients of the basis functions
for index, value in self.parameters["coefficients"][level]:
hwp.set_coefficient(0, index, value)
iv = hwp.evaluate_at(nodes, component=0, prefactor=True)
initialvalues.append(iv)
# Project the initial values to the canonical basis
initialvalues = potential.project_to_canonical(nodes, initialvalues)
# Store the initial values in a WaveFunction object
IV = WaveFunction(self.parameters)
IV.set_grid(nodes)
IV.set_values(initialvalues)
# Finally create and initialize the propagator instace
self.propagator = FourierPropagator(potential, IV, self.parameters)
# Which data do we want to save
tm = self.parameters.get_timemanager()
slots = tm.compute_number_saves()
print(tm)
self.IOManager.add_grid(self.parameters, blockid="global")
self.IOManager.add_fourieroperators(self.parameters)
self.IOManager.add_wavefunction(self.parameters, timeslots=slots)
# Write some initial values to disk
self.IOManager.save_grid(nodes, blockid="global")
self.IOManager.save_fourieroperators(self.propagator.get_operators())
self.IOManager.save_wavefunction(IV.get_values(), timestep=0)
class SimulationLoopFourier(SimulationLoop):
r"""
This class acts as the main simulation loop. It owns a propagator that
propagates a set of initial values during a time evolution. All values are
read from the ``Parameters.py`` file.
"""
def __init__(self, parameters):
r"""
Create a new simulation loop instance.
"""
# Keep a reference to the simulation parameters
self.parameters = parameters
#: The time propagator instance driving the simulation.
self.propagator = None
#: A ``IOManager`` instance for saving simulation results.
self.IOManager = None
#: The number of time steps we will perform.
self.nsteps = parameters["nsteps"]
# Set up serializing of simulation data
self.IOManager = IOManager()
self.IOManager.create_file(self.parameters)
self.IOManager.create_block()
def prepare_simulation(self):
r"""
Set up a Fourier propagator for the simulation loop. Set the
potential and initial values according to the configuration.
:raise ValueError: For invalid or missing input data.
"""
# Compute the position space grid points
nodes = self.parameters["f"] * sp.pi * sp.arange(-1, 1, 2.0/self.parameters["ngn"], dtype=np.complexfloating)
# The potential instance
potential = PF().create_potential(self.parameters)
# Check for enough initial values
if not self.parameters.has_key("initial_values"):
if len(self.parameters["parameters"]) < potential.get_number_components():
raise ValueError("Too few initial states given. Parameters are missing.")
if len(self.parameters["coefficients"]) < potential.get_number_components():
raise ValueError("Too few initial states given. Coefficients are missing.")
# Calculate the initial values sampled from a hagedorn wave packet
d = dict([("ncomponents", 1), ("basis_size", self.parameters["basis_size"]), ("eps", self.parameters["eps"])])
# Initial values given in the "fourier" specific format
if self.parameters.has_key("initial_values"):
initialvalues = [ np.zeros(nodes.shape, dtype=np.complexfloating) for i in xrange(self.parameters["ncomponents"]) ]
for level, params, coeffs in self.parameters["initial_values"]:
hwp = HagedornWavepacket(d)
hwp.set_parameters(params)
for index, value in coeffs:
hwp.set_coefficient(0, index, value)
iv = hwp.evaluate_at(nodes, component=0, prefactor=True)
initialvalues[level] = initialvalues[level] + iv
# Initial value read in compatibility mode to the packet algorithms
else:
# See if we have a list of parameter tuples or just a single 5-tuple
# This is for compatibility with the inhomogeneous case.
try:
# We have a list of parameter tuples this is ok for the loop below
len(self.parameters["parameters"][0])
parameters = self.parameters["parameters"]
except TypeError:
# We have just a single 5-tuple of parameters, we need to replicate for looping
parameters = [ self.parameters["parameters"] for i in xrange(self.parameters["ncomponents"]) ]
initialvalues = []
for level, item in enumerate(parameters):
hwp = HagedornWavepacket(d)
hwp.set_parameters(item)
# Set the coefficients of the basis functions
for index, value in self.parameters["coefficients"][level]:
hwp.set_coefficient(0, index, value)
iv = hwp.evaluate_at(nodes, component=0, prefactor=True)
initialvalues.append(iv)
# Project the initial values to the canonical basis
initialvalues = potential.project_to_canonical(nodes, initialvalues)
# Store the initial values in a WaveFunction object
IV = WaveFunction(self.parameters)
IV.set_grid(nodes)
IV.set_values(initialvalues)
# Finally create and initialize the propagator instace
self.propagator = FourierPropagator(potential, IV, self.parameters)
# Which data do we want to save
tm = self.parameters.get_timemanager()
slots = tm.compute_number_saves()
print(tm)
self.IOManager.add_grid(self.parameters, blockid="global")
self.IOManager.add_fourieroperators(self.parameters)
self.IOManager.add_wavefunction(self.parameters, timeslots=slots)
# Write some initial values to disk
self.IOManager.save_grid(nodes, blockid="global")
self.IOManager.save_fourieroperators(self.propagator.get_operators())
self.IOManager.save_wavefunction(IV.get_values(), timestep=0)
def run_simulation(self):
r"""
Run the simulation loop for a number of time steps. The number of steps is calculated in the ``initialize`` function.
"""
tm = self.parameters.get_timemanager()
# Run the simulation for a given number of timesteps
for i in xrange(1, self.nsteps+1):
print(" doing timestep "+str(i))
self.propagator.propagate()
# Save some simulation data
if tm.must_save(i):
self.IOManager.save_wavefunction(self.propagator.get_wavefunction().get_values(), timestep=i)
def end_simulation(self):
r"""
Do the necessary cleanup after a simulation. For example request the
IOManager to write the data and close the output files.
"""
self.IOManager.finalize()
