Make limit on waveform amplitude optional

qiskit/pulse/library/parametric_pulses.py

@@ -171,8 +171,11 @@ def get_waveform(self) -> Waveform:
         return gaussian(duration=self.duration, amp=self.amp, sigma=self.sigma, zero_ends=True)
 
     def validate_parameters(self) -> None:
-        if not _is_parameterized(self.amp) and abs(self.amp) > 1.0:
-            raise PulseError("The amplitude norm must be <= 1, " "found: {}".format(abs(self.amp)))
+        if not _is_parameterized(self.amp) and abs(self.amp) > 1.0 and self.limit_amplitude:
+            raise PulseError(
+                f"The amplitude norm must be <= 1, found: {abs(self.amp)}"
+                + "This can be overruled by setting Pulse.limit_amplitude."
+            )
         if not _is_parameterized(self.sigma) and self.sigma <= 0:
             raise PulseError("Sigma must be greater than 0.")
 
@@ -278,9 +281,11 @@ def get_waveform(self) -> Waveform:
         )
 
     def validate_parameters(self) -> None:
-
-        if not _is_parameterized(self.amp) and abs(self.amp) > 1.0:
-            raise PulseError("The amplitude norm must be <= 1, " "found: {}".format(abs(self.amp)))
+        if not _is_parameterized(self.amp) and abs(self.amp) > 1.0 and self.limit_amplitude:
+            raise PulseError(
+                f"The amplitude norm must be <= 1, found: {abs(self.amp)}"
+                + "This can be overruled by setting Pulse.limit_amplitude."
+            )
         if not _is_parameterized(self.sigma) and self.sigma <= 0:
             raise PulseError("Sigma must be greater than 0.")
         if self.width is not None and self.risefall_sigma_ratio is not None:
@@ -416,8 +421,11 @@ def get_waveform(self) -> Waveform:
         )
 
     def validate_parameters(self) -> None:
-        if not _is_parameterized(self.amp) and abs(self.amp) > 1.0:
-            raise PulseError("The amplitude norm must be <= 1, " "found: {}".format(abs(self.amp)))
+        if not _is_parameterized(self.amp) and abs(self.amp) > 1.0 and self.limit_amplitude:
+            raise PulseError(
+                f"The amplitude norm must be <= 1, found: {abs(self.amp)}"
+                + "This can be overruled by setting Pulse.limit_amplitude."
+            )
         if not _is_parameterized(self.sigma) and self.sigma <= 0:
             raise PulseError("Sigma must be greater than 0.")
         if not _is_parameterized(self.beta) and isinstance(self.beta, complex):
@@ -506,8 +514,11 @@ def get_waveform(self) -> Waveform:
         return constant(duration=self.duration, amp=self.amp)
 
     def validate_parameters(self) -> None:
-        if not _is_parameterized(self.amp) and abs(self.amp) > 1.0:
-            raise PulseError("The amplitude norm must be <= 1, " "found: {}".format(abs(self.amp)))
+        if not _is_parameterized(self.amp) and abs(self.amp) > 1.0 and self.limit_amplitude:
+            raise PulseError(
+                f"The amplitude norm must be <= 1, found: {abs(self.amp)}"
+                + "This can be overruled by setting Pulse.limit_amplitude."
+            )
 
     @property
     def parameters(self) -> Dict[str, Any]:

qiskit/pulse/library/pulse.py

@@ -26,10 +26,30 @@ class Pulse(ABC):
     modulation phase and frequency are specified separately from ``Pulse``s.
     """
 
+    limit_amplitude = True
+
     @abstractmethod
-    def __init__(self, duration: Union[int, ParameterExpression], name: Optional[str] = None):
+    def __init__(
+        self,
+        duration: Union[int, ParameterExpression],
+        name: Optional[str] = None,
+        limit_amplitude: Optional[bool] = None,
+    ):
+        """Abstract base class for pulses
+        Args:
+            duration: Duration of the pulse
+            name: Optional name for the pulse
+            limit_amplitude: If ``True``, then limit the amplitude of the waveform to 1.
+                             The default value of ``None`` causes the flag value to be
+                             derived from :py:attr:`~limit_amplitude` which is ``True``
+                             by default but may be set by the user to disable amplitude
+                             checks globally.
+        """
+
         self.duration = duration
         self.name = name
+        if limit_amplitude is not None:
+            self.limit_amplitude = limit_amplitude
 
     @property
     def id(self) -> int:  # pylint: disable=invalid-name

qiskit/pulse/library/waveform.py

@@ -31,6 +31,7 @@ def __init__(
         samples: Union[np.ndarray, List[complex]],
         name: Optional[str] = None,
         epsilon: float = 1e-7,
+        limit_amplitude: Optional[bool] = None,
     ):
         """Create new sample pulse command.
 
@@ -41,12 +42,13 @@ def __init__(
                 If any sample's norm exceeds unity by less than or equal to epsilon
                 it will be clipped to unit norm. If the sample
                 norm is greater than 1+epsilon an error will be raised.
+            limit_amplitude: Passed to parent Pulse
         """
 
+        super().__init__(duration=len(samples), name=name, limit_amplitude=limit_amplitude)
         samples = np.asarray(samples, dtype=np.complex_)
         self.epsilon = epsilon
         self._samples = self._clip(samples, epsilon=epsilon)
-        super().__init__(duration=len(samples), name=name)
 
     @property
     def samples(self) -> np.ndarray:
@@ -95,8 +97,12 @@ def _clip(self, samples: np.ndarray, epsilon: float = 1e-7) -> np.ndarray:
             samples[clip_where] = clipped_samples
             samples_norm[clip_where] = np.abs(clipped_samples)
 
-        if np.any(samples_norm > 1.0):
-            raise PulseError("Pulse contains sample with norm greater than 1+epsilon.")
+        if np.any(samples_norm > 1.0) and self.limit_amplitude:
+            amp = np.max(samples_norm)
+            raise PulseError(
+                f"Pulse contains sample with norm {amp} greater than 1+epsilon."
+                " This can be overruled by setting Pulse.limit_amplitude."
+            )
 
         return samples
 

releasenotes/notes/add-option-to-disable-waveform-amplitude-limit-c58e2ec61f6789e6.yaml

@@ -0,0 +1,7 @@
+---
+features:
+  - |
+    Adds a global option `limit_amplitude` to the Pulse class to enable or disable the limit of 1. on the waveform
+    amplitude. Fixes #6012.
+    With the option enabled, the `Waveform` class does not allow amplitudes larger than 1. This is
+    enforced in several subclasses such as `Gaussian` and `Constant`.

test/python/pulse/test_pulse_lib.py

@@ -13,8 +13,10 @@
 """Unit tests for pulse waveforms."""
 
 import unittest
+from unittest.mock import patch
 import numpy as np
 
+import qiskit
 from qiskit.pulse.library import (
     Waveform,
     Constant,
@@ -79,6 +81,17 @@ def test_pulse_limits(self):
         with self.assertRaises(PulseError):
             Waveform(invalid_const * np.exp(1j * 2 * np.pi * np.linspace(0, 1, 1000)))
 
+        invalid_const = 1.1
+        Waveform.limit_amplitude = False
+        wave = Waveform(invalid_const * np.exp(1j * 2 * np.pi * np.linspace(0, 1, 1000)))
+        self.assertGreater(np.max(np.abs(wave.samples)), 1.0)
+        with self.assertRaises(PulseError):
+            wave = Waveform(
+                invalid_const * np.exp(1j * 2 * np.pi * np.linspace(0, 1, 1000)),
+                limit_amplitude=True,
+            )
+        Waveform.limit_amplitude = True
+
         # Test case where data is converted to python types with complex as a list
         # with form [re, im] and back to a numpy array.
         # This is how the transport layer handles samples in the qobj so it is important
@@ -199,6 +212,12 @@ def test_constant_samples(self):
         self.assertEqual(const.get_waveform().samples[0], 0.1 + 0.4j)
         self.assertEqual(len(const.get_waveform().samples), 150)
 
+        with self.assertRaises(PulseError):
+            const = Constant(duration=150, amp=1.1 + 0.4j)
+
+        with patch("qiskit.pulse.library.parametric_pulses.Pulse.limit_amplitude", new=False):
+            const = qiskit.pulse.library.parametric_pulses.Constant(duration=150, amp=0.1 + 0.4j)
+
     def test_parameters(self):
         """Test that the parameters can be extracted as a dict through the `parameters`
         attribute."""