Tests (and minor fixes) for PulseTemplateParameterMapping and Sequenc…

…ePulseTemplate.

qctoolkit/pulses/pulse_template_parameter_mapping.py

@@ -49,7 +49,7 @@ def set_external_parameters(self, external_parameters: Optional[Set[str]]) -> No
             external_parameters (Set(str)): A set of names of external parameters. Might be None,
                 which results in no changes.
         """
-        if external_parameters:
+        if external_parameters is not None:
             self.__external_parameters = set(external_parameters.copy())
 
     @property
@@ -107,15 +107,15 @@ def get_template_map(self, template: PulseTemplate) -> Dict[str, Expression]:
         return self.__get_template_map(template).copy()
 
     def is_template_mapped(self, template: PulseTemplate) -> bool:
-        """Query whether any parameter mapping is defined for a given pusle template.
+        """Query whether a complete parameter mapping is defined for a given pulse template.
 
         Args:
             template (PulseTemplate): The pulse template for which to query the existence of
                 mappings.
         Returns:
-            True, if at least one mapping exists for template.
+            True, if all parameters of template are mapped to external parameters.
         """
-        return self.remaining_mappings(template)
+        return len(self.get_remaining_mappings(template)) == 0
 
     def get_remaining_mappings(self, template: PulseTemplate) -> Set[str]:
         """Query all currently unmapped parameters of a given pulse template.
@@ -177,7 +177,7 @@ class MissingMappingException(Exception):
     """Indicates that no mapping was specified for some parameter declaration of a
     SequencePulseTemplate's subtemplate."""
 
-    def __init__(self, template, key) -> None:
+    def __init__(self, template: PulseTemplate, key: str) -> None:
         super().__init__()
         self.key = key
         self.template = template

tests/pulses/__init__.py

@@ -8,6 +8,7 @@
     'multi_channel_pulse_template_tests',
     'parameters_tests',
     'plotting_tests',
+    'pulse_template_parameter_mapping_tests',
     'pulse_template_tests',
     'repetition_pulse_template_tests',
     'sample_pulse_generator',

tests/pulses/pulse_template_parameter_mapping_tests.py

@@ -0,0 +1,111 @@
+import unittest
+
+from qctoolkit.pulses.pulse_template_parameter_mapping import PulseTemplateParameterMapping, MissingMappingException, UnnecessaryMappingException, MissingParameterDeclarationException
+from qctoolkit.expressions import Expression
+from qctoolkit.pulses.parameters import MappedParameter, ParameterNotProvidedException, ConstantParameter
+
+from tests.pulses.sequencing_dummies import DummyPulseTemplate
+
+
+class PulseTemplateParameterMappingTests(unittest.TestCase):
+
+    def __init__(self, methodName) -> None:
+        super().__init__(methodName=methodName)
+
+    def test_empty_init(self) -> None:
+        map = PulseTemplateParameterMapping()
+        self.assertEqual(set(), map.external_parameters)
+
+    def test_set_external_parameters(self) -> None:
+        map = PulseTemplateParameterMapping({'foo'})
+        self.assertEqual({'foo'}, map.external_parameters)
+        map.set_external_parameters(None)
+        self.assertEqual({'foo'}, map.external_parameters)
+        map.set_external_parameters({'bar'})
+        self.assertEqual({'bar'}, map.external_parameters)
+        map.set_external_parameters(set())
+        self.assertEqual(set(), map.external_parameters)
+
+    def test_add_unnecessary_mapping(self) -> None:
+        map = PulseTemplateParameterMapping()
+        dummy = DummyPulseTemplate(parameter_names={'foo'})
+        with self.assertRaises(UnnecessaryMappingException):
+            map.add(dummy, 'bar', '2')
+
+    def test_add_missing_external_parameter(self) -> None:
+        map = PulseTemplateParameterMapping()
+        dummy = DummyPulseTemplate(parameter_names={'foo'})
+        with self.assertRaises(MissingParameterDeclarationException):
+            map.add(dummy, 'foo', 'bar')
+
+    def test_add(self) -> None:
+        map = PulseTemplateParameterMapping({'bar'})
+        dummy1 = DummyPulseTemplate(parameter_names={'foo', 'hugo'})
+        dummy2 = DummyPulseTemplate(parameter_names={'grr'})
+        map.add(dummy1, 'foo', '4*bar')
+        map.add(dummy2, 'grr', Expression('bar ** 2'))
+        map.add(dummy1, 'hugo', '3')
+        map.add(dummy2, 'grr', Expression('sin(bar)'))
+        self.assertEqual(dict(foo=Expression('4*bar'), hugo=Expression('3')), map.get_template_map(dummy1))
+        self.assertEqual(dict(grr=Expression('sin(bar)')), map.get_template_map(dummy2))
+
+    def test_get_template_map_no_key(self) -> None:
+        map = PulseTemplateParameterMapping()
+        dummy = DummyPulseTemplate()
+        self.assertEqual(dict(), map.get_template_map(dummy))
+
+    def test_is_template_mapped(self) -> None:
+        map = PulseTemplateParameterMapping({'bar'})
+        dummy1 = DummyPulseTemplate(parameter_names={'foo', 'hugo'})
+        dummy2 = DummyPulseTemplate(parameter_names={'grr'})
+        map.add(dummy1, 'foo', '4*bar')
+        self.assertFalse(map.is_template_mapped(dummy1))
+        map.add(dummy1, 'hugo', 'bar + 1')
+        self.assertTrue(map.is_template_mapped(dummy1))
+        self.assertFalse(map.is_template_mapped(dummy2))
+
+    def test_get_remaining_mappings(self) -> None:
+        map = PulseTemplateParameterMapping({'bar', 'barbar'})
+        dummy = DummyPulseTemplate(parameter_names={'foo', 'hugo'})
+        self.assertEqual({'foo', 'hugo'}, map.get_remaining_mappings(dummy))
+        map.add(dummy, 'hugo', '4*bar')
+        self.assertEqual({'foo'}, map.get_remaining_mappings(dummy))
+        map.add(dummy, 'foo', Expression('barbar'))
+        self.assertEqual(set(), map.get_remaining_mappings(dummy))
+
+    def test_map_parameters_not_provided(self) -> None:
+        map = PulseTemplateParameterMapping({'bar', 'barbar'})
+        dummy = DummyPulseTemplate(parameter_names={'foo', 'hugo'})
+        map.add(dummy, 'hugo', '4*bar')
+        map.add(dummy, 'foo', Expression('barbar'))
+        with self.assertRaises(ParameterNotProvidedException):
+            map.map_parameters(dummy, dict(bar=ConstantParameter(3)))
+
+    def test_map_parameters(self) -> None:
+        map = PulseTemplateParameterMapping({'bar', 'barbar'})
+        dummy = DummyPulseTemplate(parameter_names={'foo', 'hugo'})
+        map.add(dummy, 'hugo', '4*bar')
+        map.add(dummy, 'foo', Expression('barbar'))
+        mapped = map.map_parameters(dummy, dict(bar=ConstantParameter(3), barbar=ConstantParameter(5)))
+        self.assertEqual(dict(
+            hugo=MappedParameter(Expression('4*bar'), dict(bar=ConstantParameter(3))),
+            foo=MappedParameter(Expression('barbar'), dict(barbar=ConstantParameter(5)))
+        ), mapped)
+
+
+class PulseTemplateParameterMappingExceptionsTests(unittest.TestCase):
+
+    def test_missing_parameter_declaration_exception_str(self) -> None:
+        dummy = DummyPulseTemplate()
+        exception = MissingParameterDeclarationException(dummy, 'foo')
+        self.assertIsInstance(str(exception), str)
+
+    def test_missing_mapping_exception_str(self) -> None:
+        dummy = DummyPulseTemplate()
+        exception = MissingMappingException(dummy, 'foo')
+        self.assertIsInstance(str(exception), str)
+
+    def test_unnecessary_mapping_exception_str(self) -> None:
+        dummy = DummyPulseTemplate()
+        exception = MissingMappingException(dummy, 'foo')
+        self.assertIsInstance(str(exception), str)

tests/pulses/sequence_pulse_template_tests.py

@@ -11,7 +11,8 @@
 from tests.serialization_dummies import DummySerializer
 
 class SequencePulseTemplateTest(unittest.TestCase):
-    def __init__(self, *args, **kwargs):
+
+    def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
         # Setup test data
@@ -37,27 +38,40 @@ def __init__(self, *args, **kwargs):
 
         self.sequence = SequencePulseTemplate([(self.square, self.mapping1)], self.outer_parameters)
 
-    def test_missing_mapping(self):
+    def test_missing_mapping(self) -> None:
         mapping = self.mapping1
         mapping.pop('v')
 
         subtemplates = [(self.square, mapping)]
         with self.assertRaises(MissingMappingException):
             SequencePulseTemplate(subtemplates, self.outer_parameters)
 
-    def test_unnecessary_mapping(self):
+    def test_unnecessary_mapping(self) -> None:
         mapping = self.mapping1
         mapping['unnecessary'] = 'voltage'
 
         subtemplates = [(self.square, mapping)]
         with self.assertRaises(UnnecessaryMappingException):
             SequencePulseTemplate(subtemplates, self.outer_parameters)
 
-    def test_identifier(self):
+    def test_identifier(self) -> None:
         identifier = 'some name'
         pulse = SequencePulseTemplate([], [], identifier=identifier)
         self.assertEqual(identifier, pulse.identifier)
 
+    def test_multiple_channels(self) -> None:
+        dummy = DummyPulseTemplate(parameter_names={'hugo'}, num_channels=2)
+        subtemplates = [(dummy, {'hugo': 'foo'}), (dummy, {'hugo': '3'})]
+        sequence = SequencePulseTemplate(subtemplates, {'foo'})
+        self.assertEqual(2, sequence.num_channels)
+
+    def test_multiple_channels_mismatch(self) -> None:
+        dummy1 = DummyPulseTemplate(num_channels=6)
+        dummy2 = DummyPulseTemplate(num_channels=5)
+        subtemplates = [(dummy1, dict()), (dummy2, dict())]
+        with self.assertRaises(ValueError):
+            SequencePulseTemplate(subtemplates, set())
+
 
 class SequencePulseTemplateSerializationTests(unittest.TestCase):