Merge pull request #358 from qutech/fix/default_channel_mapping

Add correct default channel mappings
qutech · Aug 29, 2018 · e02a121 · e02a121
2 parents 55d1609 + 083dd2c
commit e02a121
Show file tree

Hide file tree

Showing 2 changed files with 30 additions and 5 deletions.
diff --git a/qctoolkit/pulses/pulse_template.py b/qctoolkit/pulses/pulse_template.py
@@ -9,7 +9,7 @@
 from abc import abstractmethod
 from typing import Dict, Tuple, Set, Optional, Union, List, Callable, Any, Generic, TypeVar, Mapping
 import itertools
-from contextlib import contextmanager
+import collections
 from numbers import Real
 
 from qctoolkit.utils.types import ChannelID, DocStringABCMeta
@@ -126,6 +126,16 @@ def create_program(self, *,
         if to_single_waveform is None:
             to_single_waveform = set()
 
+        for channel in self.defined_channels:
+            if channel not in channel_mapping:
+                channel_mapping[channel] = channel
+
+        non_unique_targets = {channel
+                              for channel, count in collections.Counter(channel_mapping.values()).items()
+                              if count > 1 and channel is not None}
+        if non_unique_targets:
+            raise ValueError('The following channels are mapped to twice', non_unique_targets)
+
         # make sure all values in the parameters dict are of type Parameter
         for (key, value) in parameters.items():
             if not isinstance(value, Parameter):

diff --git a/tests/pulses/pulse_template_tests.py b/tests/pulses/pulse_template_tests.py
@@ -166,7 +166,7 @@ def test_create_program(self) -> None:
         template = PulseTemplateStub(defined_channels={'A'}, parameter_names={'foo'})
         parameters = {'foo': ConstantParameter(2.126), 'bar': -26.2, 'hugo': '2*x+b', 'append_a_child': '1'}
         measurement_mapping = {'M': 'N'}
-        channel_mapping = {'B': 'A'}
+        channel_mapping = {'A': 'B'}
 
         expected_parameters = {'foo': ConstantParameter(2.126), 'bar': ConstantParameter(-26.2),
                                'hugo': ConstantParameter('2*x+b'), 'append_a_child': ConstantParameter('1')}
@@ -273,11 +273,11 @@ def test__create_program_single_waveform(self):
                         self.assertEqual(expected_program, parent_loop)
 
     def test_create_program_defaults(self) -> None:
-        template = PulseTemplateStub(defined_channels={'A'}, parameter_names={'foo'}, measurement_names={'hugo', 'foo'})
+        template = PulseTemplateStub(defined_channels={'A', 'B'}, parameter_names={'foo'}, measurement_names={'hugo', 'foo'})
 
         expected_internal_kwargs = dict(parameters=dict(),
                                         measurement_mapping={'hugo': 'hugo', 'foo': 'foo'},
-                                        channel_mapping=dict(),
+                                        channel_mapping={'A': 'A', 'B': 'B'},
                                         global_transformation=None,
                                         to_single_waveform=set())
 
@@ -291,11 +291,26 @@ def test_create_program_defaults(self) -> None:
             _internal_create_program.assert_called_once_with(**expected_internal_kwargs, parent_loop=program)
         self.assertEqual(expected_program, program)
 
+    def test_create_program_channel_mapping(self):
+        template = PulseTemplateStub(defined_channels={'A', 'B'})
+
+        expected_internal_kwargs = dict(parameters=dict(),
+                                        measurement_mapping=dict(),
+                                        channel_mapping={'A': 'C', 'B': 'B'},
+                                        global_transformation=None,
+                                        to_single_waveform=set())
+
+        with mock.patch.object(template, '_internal_create_program') as _internal_create_program:
+            template.create_program(channel_mapping={'A': 'C'})
+
+            _internal_create_program.assert_called_once_with(**expected_internal_kwargs, parent_loop=Loop())
+
+
     def test_create_program_none(self) -> None:
         template = PulseTemplateStub(defined_channels={'A'}, parameter_names={'foo'})
         parameters = {'foo': ConstantParameter(2.126), 'bar': -26.2, 'hugo': '2*x+b'}
         measurement_mapping = {'M': 'N'}
-        channel_mapping = {'B': 'A'}
+        channel_mapping = {'A': 'B'}
         expected_parameters = {'foo': ConstantParameter(2.126), 'bar': ConstantParameter(-26.2),
                                'hugo': ConstantParameter('2*x+b')}
         expected_internal_kwargs = dict(parameters=expected_parameters,