def _internal_create_program(
self, *, scope: Scope, measurement_mapping: Dict[str,
Optional[str]],
channel_mapping: Dict[ChannelID, Optional[ChannelID]],
global_transformation: Optional['Transformation'],
to_single_waveform: Set[Union[str, 'PulseTemplate']],
parent_loop: Loop) -> None:
self.validate_scope(scope=scope)
try:
duration = self.duration.evaluate_in_scope(scope)
except ExpressionVariableMissingException as err:
raise ParameterNotProvidedException(err.variable) from err
if duration > 0:
measurements = self.get_measurement_windows(
scope, measurement_mapping)
if measurements:
parent_loop.add_measurements(measurements)
for local_scope in self._body_scope_generator(scope, forward=True):
self.body._create_program(
scope=local_scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=global_transformation,
to_single_waveform=to_single_waveform,
parent_loop=parent_loop)
def requires_stop(self, parameters: Dict[str, Parameter],
conditions: Dict[str, 'Condition']) -> bool:
try:
return any(parameters[name].requires_stop
for name in self.parameter_names)
except KeyError as key_error:
raise ParameterNotProvidedException(str(key_error)) from key_error
def _internal_create_program(
self, *, scope: Scope, measurement_mapping: Dict[str,
Optional[str]],
channel_mapping: Dict[ChannelID, Optional[ChannelID]],
global_transformation: Optional[Transformation],
to_single_waveform: Set[Union[str, PulseTemplate]],
parent_loop: Loop) -> None:
""" removed from qupulse docstring """
try:
parameters = {
parameter_name: scope[parameter_name].get_value()
for parameter_name in self.parameter_names
}
except KeyError as e:
raise ParameterNotProvidedException(str(e)) from e
waveform = self.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
if waveform:
measurements: List[Any] = []
measurements = self.get_measurement_windows(
parameters=parameters, measurement_mapping=measurement_mapping)
if global_transformation:
waveform = TransformingWaveform(waveform,
global_transformation)
parent_loop.add_measurements(measurements=measurements)
parent_loop.append_child(waveform=waveform)
def _internal_create_program(self, *,
parameters: Dict[str, Parameter],
measurement_mapping: Dict[str, Optional[str]],
channel_mapping: Dict[ChannelID, Optional[ChannelID]],
global_transformation: Optional[Transformation],
to_single_waveform: Set[Union[str, 'PulseTemplate']],
parent_loop: Loop) -> None:
"""Parameter constraints are validated in build_waveform because build_waveform is guaranteed to be called
during sequencing"""
### current behavior (same as previously): only adds EXEC Loop and measurements if a waveform exists.
### measurements are directly added to parent_loop (to reflect behavior of Sequencer + MultiChannelProgram)
# todo (2018-08-08): could move measurements into own Loop object?
# todo (2018-07-05): why are parameter constraints not validated here?
try:
parameters = {parameter_name: parameters[parameter_name].get_value()
for parameter_name in self.parameter_names}
except KeyError as e:
raise ParameterNotProvidedException(str(e)) from e
waveform = self.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
if waveform:
measurements = self.get_measurement_windows(parameters=parameters,
measurement_mapping=measurement_mapping)
if global_transformation:
waveform = TransformingWaveform(waveform, global_transformation)
parent_loop.add_measurements(measurements=measurements)
parent_loop.append_child(waveform=waveform)
def _internal_create_program(self, *,
parameters: Dict[str, Parameter],
measurement_mapping: Dict[str, Optional[str]],
channel_mapping: Dict[ChannelID, Optional[ChannelID]],
global_transformation: Optional['Transformation'],
to_single_waveform: Set[Union[str, 'PulseTemplate']],
parent_loop: Loop) -> None:
self.validate_parameter_constraints(parameters=parameters)
try:
measurement_parameters = {parameter_name: parameters[parameter_name].get_value()
for parameter_name in self.measurement_parameters}
duration_parameters = {parameter_name: parameters[parameter_name].get_value()
for parameter_name in self.duration.variables}
except KeyError as e:
raise ParameterNotProvidedException(str(e)) from e
if self.duration.evaluate_numeric(**duration_parameters) > 0:
measurements = self.get_measurement_windows(measurement_parameters, measurement_mapping)
if measurements:
parent_loop.add_measurements(measurements)
for local_parameters in self._body_parameter_generator(parameters, forward=True):
self.body._create_program(parameters=local_parameters,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=global_transformation,
to_single_waveform=to_single_waveform,
parent_loop=parent_loop)
def _internal_create_program(self, *,
parameters: Dict[str, Parameter],
measurement_mapping: Dict[str, Optional[str]],
channel_mapping: Dict[ChannelID, Optional[ChannelID]],
global_transformation: Optional['Transformation'],
to_single_waveform: Set[Union[str, 'PulseTemplate']],
parent_loop: Loop) -> None:
self.validate_parameter_constraints(parameters=parameters)
relevant_params = set(self._repetition_count.variables).union(self.measurement_parameters)
try:
real_parameters = {v: parameters[v].get_value() for v in relevant_params}
except KeyError as e:
raise ParameterNotProvidedException(str(e)) from e
repetition_count = max(0, self.get_repetition_count_value(real_parameters))
# todo (2018-07-19): could in some circumstances possibly just multiply subprogram repetition count?
# could be tricky if any repetition count is volatile ? check later and optimize if necessary
if repetition_count > 0:
repj_loop = Loop(repetition_count=repetition_count)
self.body._create_program(parameters=parameters,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=global_transformation,
to_single_waveform=to_single_waveform,
parent_loop=repj_loop)
if repj_loop.waveform is not None or len(repj_loop.children) > 0:
measurements = self.get_measurement_windows(real_parameters, measurement_mapping)
if measurements:
parent_loop.add_measurements(measurements)
parent_loop.append_child(loop=repj_loop)
def build_sequence(self,
sequencer: Sequencer,
parameters: Dict[str, Parameter],
conditions: Dict[str, Condition],
measurement_mapping: Dict[str, Optional[str]],
channel_mapping: Dict[ChannelID, Optional[ChannelID]],
instruction_block: InstructionBlock) -> None:
self.validate_parameter_constraints(parameters=parameters)
try:
real_parameters = {v: parameters[v].get_value() for v in self._repetition_count.variables}
except KeyError:
raise ParameterNotProvidedException(next(v for v in self.repetition_count.variables if v not in parameters))
self.insert_measurement_instruction(instruction_block,
parameters=parameters,
measurement_mapping=measurement_mapping)
repetition_count = self.get_repetition_count_value(real_parameters)
if repetition_count > 0:
body_block = InstructionBlock()
body_block.return_ip = InstructionPointer(instruction_block, len(instruction_block))
instruction_block.add_instruction_repj(repetition_count, body_block)
sequencer.push(self.body, parameters=parameters, conditions=conditions,
window_mapping=measurement_mapping, channel_mapping=channel_mapping, target_block=body_block)
def _validate_parameters(self, parameters: Dict[str, Union[Parameter,
numbers.Real]],
volatile: Set[str]):
missing = set(self.__external_parameters) - set(parameters.keys())
if missing:
raise ParameterNotProvidedException(missing.pop())
self.validate_parameter_constraints(parameters=parameters,
volatile=volatile)
def get_entries_instantiated(self, parameters: Dict[str, numbers.Real]) \
-> Dict[ChannelID, List[TableWaveformEntry]]:
"""Compute an instantiated list of the table's entries.
Args:
parameters (Dict(str -> Parameter)): A mapping of parameter names to Parameter objects.
Returns:
(float, float)-list of all table entries with concrete values provided by the given
parameters.
"""
if not (self.table_parameters <= set(parameters.keys())):
raise ParameterNotProvidedException(
(self.table_parameters - set(parameters.keys())).pop())
instantiated_entries = dict(
) # type: Dict[ChannelID,List[TableWaveformEntry]]
for channel, channel_entries in self._entries.items():
instantiated = [
entry.instantiate(parameters) for entry in channel_entries
]
# Add (0, v) entry if wf starts at finite time
if instantiated[0].t > 0:
instantiated.insert(
0,
TableWaveformEntry(
0, instantiated[0].v,
TablePulseTemplate.interpolation_strategies['hold']))
instantiated_entries[channel] = instantiated
duration = max(instantiated[-1].t
for instantiated in instantiated_entries.values())
# ensure that all channels have equal duration
for channel, instantiated in instantiated_entries.items():
final_entry = instantiated[-1]
if final_entry.t < duration:
instantiated.append(
TableWaveformEntry(
duration, final_entry.v,
TablePulseTemplate.interpolation_strategies['hold']))
instantiated_entries[channel] = instantiated
return instantiated_entries
def map_parameters(
self, parameters: Dict[str, Union[Parameter, numbers.Real]]
) -> Dict[str, Parameter]:
"""Map parameter values according to the defined mappings.
Args:
parameters (Dict(str -> Parameter)): A mapping of parameter names to Parameter
objects/values.
Returns:
A new dictionary which maps parameter names to parameter values which have been
mapped according to the mappings defined for template.
"""
missing = set(self.__external_parameters) - set(parameters.keys())
if missing:
raise ParameterNotProvidedException(missing.pop())
self.validate_parameter_constraints(parameters=parameters)
if all(
isinstance(parameter, Parameter)
for parameter in parameters.values()):
return {
parameter: MappedParameter(mapping_function, {
name: parameters[name]
for name in mapping_function.variables
})
for (parameter,
mapping_function) in self.__parameter_mapping.items()
}
if all(
isinstance(parameter, numbers.Real)
for parameter in parameters.values()):
return {
parameter: mapping_function.evaluate_numeric(**parameters)
for parameter, mapping_function in
self.__parameter_mapping.items()
}
raise TypeError(
'Values of parameter dict are neither all Parameter nor Real')
def test(self) -> None:
exc = ParameterNotProvidedException('foo')
self.assertEqual("No value was provided for parameter 'foo'.",
str(exc))
