2523398954

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/qutip/qutip-qip/commit/<a class=hub.com/qutip/qutip-qip/commit/<a class="double-link" href="https://git"><a class=hub.com/qutip/qutip-qip/commit/<a class="double-link" href="https://git"><a class=hub.com/qutip/qutip-qip/commit/<a class="double-link" href="https://git"><a class=hub.com/qutip/qutip-qip/commit/<a class="double-link" href="https://git"><a class=hub.com/qutip/qutip-qip/commit/5cfac43cc9938489dba2ee04fe80031ccd1b3a92">5cfac43cc">&lt;a href=&quot;https://github.com/qutip/qutip-qip/commit/</a><a class="double-link" href="https://github.com/qutip/qutip-qip/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/qutip/qutip-qip/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/qutip/qutip-qip/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/qutip/qutip-qip/commit/5cfac43cc9938489dba2ee04fe80031ccd1b3a92">5cfac43cc</a><a href="https://github.com/qutip/qutip-qip/commit/5cfac43cc9938489dba2ee04fe80031ccd1b3a92">&lt;a href=&quot;https://github.com/qutip/qutip-qip/commit/5cfac43cc9938489dba2ee04fe80031ccd1b3a92&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/qutip/qutip-qip/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/qutip/qutip-qip/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/qutip/qutip-qip/commit/5cfac43cc9938489dba2ee04fe80031ccd1b3a92&amp;quot;&amp;gt;5cfac43cc&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/qutip/qutip-qip/commit/5cfac43cc9938489dba2ee04fe80031ccd1b3a92&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/qutip/qutip-qip/commit/5cfac43cc9938489dba2ee04fe80031c&amp;lt;/a&amp;gt;cd1</a>b3a92&quot;&gt;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/qutip/qutip-qip/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/qutip/qutip-qip/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/qutip/qutip-qip/commit/d320933bd&quot;&gt;d320933bd&lt;/a&gt;&lt;a href=&quot;htt... (continued)

Pull Request Pull Request #151: Prepare the qutip-qip-0.2.2 release

Run Details

65 of 91 new or added lines in 8 files covered. (71.43%)

3331 of 3937 relevant lines covered (84.61%)

5.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.73

/src/qutip_qip/compiler/gatecompiler.py

import warnings
import numpy as np
from scipy import signal

from .instruction import Instruction
from .scheduler import Scheduler
from ..circuit import QubitCircuit
from ..operations import Gate


__all__ = ["GateCompiler"]


class GateCompiler(object):
    """
    Base class of compilers, including the :meth:`GateCompiler.compile` method.
    It compiles a :class:`.QubitCircuit` into
    the pulse sequence for the processor. The core member function
    `compile` calls compiling method from the sub-class and concatenate
    the compiled pulses.

    Parameters
    ----------
    num_qubits: int
        The number of the component systems.

    params: dict, optional
        A Python dictionary contains the name and the value of the parameters,
        such as laser frequency, detuning etc.
        It will be saved in the class attributes and can be used to calculate
        the control pulses.

    Attributes
    ----------
    gate_compiler: dict
        The Python dictionary in the form of {gate_name: compiler_function}.
        It saves the compiling routine for each gate. See sub-classes
        for implementation.
        Note that for continuous pulse, the first coeff should always be 0.

    args: dict
        The compilation configurations.
        It will be passed to each compiling functions.
        Available arguments:

        * ``shape``: The compiled pulse shape. ``rectangular`` or
          one of the `SciPy window functions
          <https://docs.scipy.org/doc/scipy/reference/signal.windows.html>`_.
        * ``num_samples``:
          Number of samples for continuous pulses.
          It has no effect for rectangular pulses.
        * ``params``: Hardware parameters computed in the :obj:`Processor`.

    """

    def __init__(self, num_qubits=None, params=None, pulse_dict=None, N=None):
        self.gate_compiler = {}
        self.num_qubits = num_qubits or N
        self.N = num_qubits  # backward compatibility
        self.params = params if params is not None else {}
        self.gate_compiler = {
            "GLOBALPHASE": self.globalphase_compiler,
            "IDLE": self.idle_compiler,
        }
        self.args = {  # Default configuration
            "shape": "rectangular",
            "num_samples": None,
            "params": self.params,
        }
        self.global_phase = 0.0
        if pulse_dict is not None:
            warnings.warn(
                """
                Giving pulse_dict to compiler is deprecated.
                The compiler now returns the compiled pulses as a dictionary
                between the pulse's label and the coefficients/tlist.
                It can be given to the processor directly.
                The parameter pulse_dict has no effect now,
                you can simply remove it.
                """,
                DeprecationWarning,
            )

    def globalphase_compiler(self, gate, args):
        """
        Compiler for the GLOBALPHASE gate
        """
        pass

    def idle_compiler(self, gate, args):
        """
        Compiler for the GLOBALPHASE gate
        """
        idle_time = gate.arg_value
        return [Instruction(gate, idle_time, [])]

    def compile(self, circuit, schedule_mode=None, args=None):
        """
        Compile the the native gates into control pulse sequence.
        It calls each compiling method and concatenates
        the compiled pulses.

        Parameters
        ----------
        circuit: :class:`.QubitCircuit` or list of
            :class:`.Gate`
            A list of elementary gates that can be implemented in the
            corresponding hardware.
            The gate names have to be in `gate_compiler`.

        schedule_mode: str, optional
            ``"ASAP"`` for "as soon as possible" or
            ``"ALAP"`` for "as late as possible" or
            ``False`` or ``None`` for no schedule.
            Default is None.

        args: dict, optional
            A dictionary of arguments used in a specific gate compiler
            function.

        Returns
        -------
        tlist, coeffs: array_like or dict
            Compiled ime sequence and pulse coefficients.
            if ``return_array`` is true, return
            A 2d NumPy array of the shape ``(len(ctrls), len(tlist))``.
            Each row corresponds to the control pulse sequence for
            one Hamiltonian.
            if ``return_array`` is false
        """
        if isinstance(circuit, QubitCircuit):
            gates = circuit.gates
        else:
            gates = circuit
        if args is not None:
            self.args.update(args)
        instruction_list = []

        # compile gates
        for gate in gates:
            if gate.name not in self.gate_compiler:
                raise ValueError("Unsupported gate %s" % gate.name)
            instruction = self.gate_compiler[gate.name](gate, self.args)
            if instruction is None:
                continue  # neglecting global phase gate
            instruction_list += instruction
        if not instruction_list:
            return None, None

        # schedule
        # scheduled_start_time:
        #   An ordered list of the start_time for each pulse,
        #   corresponding to gates in the instruction_list.
        # instruction_list reordered according to the scheduled result
        instruction_list, scheduled_start_time = self._schedule(
            instruction_list, schedule_mode
        )

        # An instruction can be composed from several different pulse elements.
        # We separate them an assign them to each pulse index.
        pulse_ind_map = {}
        next_pulse_ind = 0
        pulse_instructions = []
        for instruction, start_time in zip(
            instruction_list, scheduled_start_time
        ):
            for pulse_name, coeff in instruction.pulse_info:
                if pulse_name not in pulse_ind_map:
                    pulse_instructions.append([])
                    pulse_ind_map[pulse_name] = next_pulse_ind
                    next_pulse_ind += 1
                pulse_instructions[pulse_ind_map[pulse_name]].append(
                    (start_time, instruction.tlist, coeff)
                )

        # concatenate pulses
        compiled_tlist, compiled_coeffs = self._concatenate_pulses(
            pulse_instructions, scheduled_start_time, len(pulse_instructions)
        )
        compiled_tlist_map, compiled_coeffs_map = {}, {}
        for key, index in pulse_ind_map.items():
            compiled_tlist_map[key] = compiled_tlist[index]
            compiled_coeffs_map[key] = compiled_coeffs[index]
        return compiled_tlist_map, compiled_coeffs_map

    def _schedule(self, instruction_list, schedule_mode):
        """
        Schedule the instructions if required and
        reorder instruction_list accordingly
        """
        if schedule_mode:
            scheduler = Scheduler(schedule_mode)
            scheduled_start_time = scheduler.schedule(instruction_list)
            time_ordered_pos = np.argsort(scheduled_start_time)
            instruction_list = [instruction_list[i] for i in time_ordered_pos]
            scheduled_start_time.sort()
        else:  # no scheduling
            scheduled_start_time = [0.0]
            for instruction in instruction_list[:-1]:
                scheduled_start_time.append(
                    instruction.duration + scheduled_start_time[-1]
                )
        return instruction_list, scheduled_start_time

    def _concatenate_pulses(
        self, pulse_instructions, scheduled_start_time, num_controls
    ):
        """
        Concatenate compiled pulses coefficients and tlist for each pulse.
        If there is idling time, add zeros properly to prevent wrong spline.
        """
        min_step_size = np.inf
        # Concatenate tlist and coeffs for each control pulses
        compiled_tlist = [[] for tmp in range(num_controls)]
        compiled_coeffs = [[] for tmp in range(num_controls)]
        for pulse_ind in range(num_controls):
            last_pulse_time = 0.0
            for start_time, tlist, coeff in pulse_instructions[pulse_ind]:
                # compute the gate time, step size and coeffs
                # according to different pulse mode
                (
                    gate_tlist,
                    coeffs,
                    step_size,
                    pulse_mode,
                ) = self._process_gate_pulse(start_time, tlist, coeff)
                min_step_size = min(step_size, min_step_size)

                if abs(last_pulse_time) < step_size * 1.0e-6:  # if first pulse
                    compiled_tlist[pulse_ind].append([0.0])
                    if pulse_mode == "continuous":
                        compiled_coeffs[pulse_ind].append([0.0])
                    # for discrete pulse len(coeffs) = len(tlist) - 1

                # If there is idling time between the last pulse and
                # the current one, we need to add zeros in between.
                if np.abs(start_time - last_pulse_time) > step_size * 1.0e-6:
                    idling_tlist = self._process_idling_tlist(
                        pulse_mode, start_time, last_pulse_time, step_size
                    )
                    compiled_tlist[pulse_ind].append(idling_tlist)
                    compiled_coeffs[pulse_ind].append(
                        np.zeros(len(idling_tlist))
                    )

                # Add the gate time and coeffs to the list.
                execution_time = gate_tlist + start_time
                last_pulse_time = execution_time[-1]
                compiled_tlist[pulse_ind].append(execution_time)
                compiled_coeffs[pulse_ind].append(coeffs)

        final_time = np.max([tlist[-1] for tlist in compiled_tlist])
        for pulse_ind in range(num_controls):
            if not compiled_tlist[pulse_ind]:
                continue
            last_pulse_time = compiled_tlist[pulse_ind][-1][-1]
            if np.abs(final_time - last_pulse_time) > min_step_size * 1.0e-6:
                idling_tlist = self._process_idling_tlist(
                    pulse_mode, final_time, last_pulse_time, min_step_size
                )
                compiled_tlist[pulse_ind].append(idling_tlist)
                compiled_coeffs[pulse_ind].append(np.zeros(len(idling_tlist)))

        for i in range(num_controls):
            if not compiled_coeffs[i]:
                compiled_tlist[i] = None
                compiled_coeffs[i] = None
            else:
                compiled_tlist[i] = np.concatenate(compiled_tlist[i])
                compiled_coeffs[i] = np.concatenate(compiled_coeffs[i])
        return compiled_tlist, compiled_coeffs

    def _process_gate_pulse(self, start_time, tlist, coeff):
        # compute the gate time, step size and coeffs
        # according to different pulse mode
        if np.isscalar(tlist):
            pulse_mode = "discrete"
            # a single constant rectanglar pulse, where
            # tlist and coeff are just float numbers
            step_size = tlist
            coeff = np.array([coeff])
            gate_tlist = np.array([tlist])
        elif len(tlist) - 1 == len(coeff):
            # discrete pulse
            pulse_mode = "discrete"
            step_size = tlist[1] - tlist[0]
            coeff = np.asarray(coeff)
            gate_tlist = np.asarray(tlist)[1:]  # first t always 0 by def
        elif len(tlist) == len(coeff):
            # continuos pulse
            pulse_mode = "continuous"
            step_size = tlist[1] - tlist[0]
            coeff = np.asarray(coeff)[1:]
            gate_tlist = np.asarray(tlist)[1:]
        else:
            raise ValueError("The shape of the compiled pulse is not correct.")
        return gate_tlist, coeff, step_size, pulse_mode

    def _process_idling_tlist(
        self, pulse_mode, start_time, last_pulse_time, step_size
    ):
        idling_tlist = []
        if pulse_mode == "continuous":
            # We add sufficient number of zeros at the begining
            # and the end of the idling to prevent wrong cubic spline.
            if start_time - last_pulse_time > 3 * step_size:
                idling_tlist1 = np.linspace(
                    last_pulse_time + step_size / 5,
                    last_pulse_time + step_size,
                    5,
                )
                idling_tlist2 = np.linspace(
                    start_time - step_size, start_time, 5
                )
                idling_tlist.extend([idling_tlist1, idling_tlist2])
            else:
                idling_tlist.append(
                    np.arange(
                        last_pulse_time + step_size, start_time, step_size
                    )
                )
        elif pulse_mode == "discrete":
            # idling until the start time
            idling_tlist.append([start_time])
        return np.concatenate(idling_tlist)

    @classmethod
    def generate_pulse_shape(cls, shape, num_samples, maximum=1.0, area=1.0):
        """
        Return a tuple consisting of a coeff list and a time sequence
        according to a given pulse shape.

        Parameters
        ----------
        shape : str
            The name ``"rectangular"`` for constant pulse or
            the name of a Scipy window function.
            See
            `the Scipy documentation
            <https://docs.scipy.org/doc/scipy/reference/signal.windows.html>`_
            for detail.
        num_samples : int
            The number of the samples of the coefficients.
        maximum : float, optional
            The maximum of the coefficients.
            The absolute value will be used if negative.
        area : float, optional
            The total area if one integrates coeff as a function of the time.
            If the area is negative, the pulse is flipped vertically
            (i.e. the pulse is multiplied by the sign of the area).

        Returns
        -------
        coeff, tlist :
            If the default window ``"shape"="rectangular"`` is used,
            both are float numbers.
            If Scipy window functions are used, both are a 1-dimensional numpy
            array with the same size.

        Notes
        -----
        If Scipy window functions are used, it is suggested to set
        ``Processor.pulse_mode`` to ``"continuous"``.
        Notice that finite number of sampling points will also make
        the total integral of the coefficients slightly deviate from ``area``.

        Examples
        --------
        .. plot::
            :context: reset

            from qutip_qip.compiler import GateCompiler
            import numpy as np
            compiler = GateCompiler()
            coeff, tlist= compiler.generate_pulse_shape(
                "hann",  # Scipy Hann window
                1000,  # 100 sampling point
                maximum=3.,
                # Notice that 2 pi is added to H by qutip solvers.
                area= 1.,
            )

        We can plot the generated pulse shape:

        .. plot::
            :context: close-figs

            import matplotlib.pyplot as plt
            plt.plot(tlist, coeff)
            plt.show()

        The pulse is normalized to fit the area. Notice that due to
        the finite number of sampling points, it is not exactly 1.

        .. testsetup::

            from qutip_qip.compiler import GateCompiler
            import numpy as np
            compiler = GateCompiler()
            coeff, tlist= compiler.generate_pulse_shape(
                "hann",  # Scipy Hann window
                1000,  # 100 sampling point
                maximum=3.,
                # Notice that 2 pi is added to H by qutip solvers.
                area= 1.,
            )

        .. doctest::

            >>> round(np.trapz(coeff, tlist), 2)
            1.0
        """
        coeff, tlist = _normalized_window(shape, num_samples)
        sign = np.sign(area)
        coeff *= np.abs(maximum) * sign
        tlist *= abs(area) / np.abs(maximum)
        return coeff, tlist


_default_window_t_max = {
    "boxcar": 1.0,
    "triang": 2.0,
    "blackman": 1.0 / 0.42,
    "hamming": 1.0 / 0.54,
    "hann": 2.0,
    "bartlett": 2.0,
    "flattop": 1.0 / 0.21557897160000217,
    "parzen": 1.0 / 0.375,
    "bohman": 1.0 / 0.4052847750978287,
    "blackmanharris": 1.0 / 0.35875003586900384,
    "nuttall": 1.0 / 0.36358193632191405,
    "barthann": 2.0,
    "cosine": np.pi / 2.0,
}


def _normalized_window(shape, num_samples):
    """
    Normalized SciPy window functions.
    The SciPy implementation only makes sure that it is maximum is 1.
    Here, we save a default t_max so that the integral is always 1.
    """
    if shape == "rectangular":
        return 1.0, 1.0
    t_max = _default_window_t_max.get(shape, None)
    if t_max is None:
        raise ValueError(f"Window function {shape} is not supported.")
    coeff = signal.windows.get_window(shape, num_samples)
    tlist = np.linspace(0, t_max, num_samples)
    return coeff, tlist

1	import warnings	6✔
2	import numpy as np	6✔
3	from scipy import signal	6✔
4
5	from .instruction import Instruction	6✔
6	from .scheduler import Scheduler	6✔
7	from ..circuit import QubitCircuit	6✔
8	from ..operations import Gate	6✔
9
10
11	__all__ = ["GateCompiler"]	6✔
12
13
14	class GateCompiler(object):	6✔
15	"""
16	Base class of compilers, including the :meth:`GateCompiler.compile` method.
17	It compiles a :class:`.QubitCircuit` into
18	the pulse sequence for the processor. The core member function
19	`compile` calls compiling method from the sub-class and concatenate
20	the compiled pulses.
21
22	Parameters
23	----------
24	num_qubits: int
25	The number of the component systems.
26
27	params: dict, optional
28	A Python dictionary contains the name and the value of the parameters,
29	such as laser frequency, detuning etc.
30	It will be saved in the class attributes and can be used to calculate
31	the control pulses.
32
33	Attributes
34	----------
35	gate_compiler: dict
36	The Python dictionary in the form of {gate_name: compiler_function}.
37	It saves the compiling routine for each gate. See sub-classes
38	for implementation.
39	Note that for continuous pulse, the first coeff should always be 0.
40
41	args: dict
42	The compilation configurations.
43	It will be passed to each compiling functions.
44	Available arguments:
45
46	* ``shape``: The compiled pulse shape. ``rectangular`` or
47	one of the `SciPy window functions
48	<https://docs.scipy.org/doc/scipy/reference/signal.windows.html>`_.
49	* ``num_samples``:
50	Number of samples for continuous pulses.
51	It has no effect for rectangular pulses.
52	* ``params``: Hardware parameters computed in the :obj:`Processor`.
53
54	"""
55
56	def __init__(self, num_qubits=None, params=None, pulse_dict=None, N=None):	6✔
57	self.gate_compiler = {}	6✔
58	self.num_qubits = num_qubits or N	6✔
59	self.N = num_qubits # backward compatibility	6✔
60	self.params = params if params is not None else {}	6✔
61	self.gate_compiler = {	6✔
62	"GLOBALPHASE": self.globalphase_compiler,
63	"IDLE": self.idle_compiler,
64	}
65	self.args = { # Default configuration	6✔
66	"shape": "rectangular",
67	"num_samples": None,
68	"params": self.params,
69	}
70	self.global_phase = 0.0	6✔
71	if pulse_dict is not None:	6✔
72	warnings.warn(	×
73	"""
74	Giving pulse_dict to compiler is deprecated.
75	The compiler now returns the compiled pulses as a dictionary
76	between the pulse's label and the coefficients/tlist.
77	It can be given to the processor directly.
78	The parameter pulse_dict has no effect now,
79	you can simply remove it.
80	""",
81	DeprecationWarning,
82	)
83
84	def globalphase_compiler(self, gate, args):	6✔
85	"""
86	Compiler for the GLOBALPHASE gate
87	"""
88	pass	6✔
89
90	def idle_compiler(self, gate, args):	6✔
91	"""
92	Compiler for the GLOBALPHASE gate
93	"""
94	idle_time = gate.arg_value	6✔
95	return [Instruction(gate, idle_time, [])]	6✔
96
97	def compile(self, circuit, schedule_mode=None, args=None):	6✔
98	"""
99	Compile the the native gates into control pulse sequence.
100	It calls each compiling method and concatenates
101	the compiled pulses.
102
103	Parameters
104	----------
105	circuit: :class:`.QubitCircuit` or list of
106	:class:`.Gate`
107	A list of elementary gates that can be implemented in the
108	corresponding hardware.
109	The gate names have to be in `gate_compiler`.
110
111	schedule_mode: str, optional
112	``"ASAP"`` for "as soon as possible" or
113	``"ALAP"`` for "as late as possible" or
114	``False`` or ``None`` for no schedule.
115	Default is None.
116
117	args: dict, optional
118	A dictionary of arguments used in a specific gate compiler
119	function.
120
121	Returns
122	-------
123	tlist, coeffs: array_like or dict
124	Compiled ime sequence and pulse coefficients.
125	if ``return_array`` is true, return
126	A 2d NumPy array of the shape ``(len(ctrls), len(tlist))``.
127	Each row corresponds to the control pulse sequence for
128	one Hamiltonian.
129	if ``return_array`` is false
130	"""
131	if isinstance(circuit, QubitCircuit):	6✔
132	gates = circuit.gates	6✔
133	else:
134	gates = circuit	6✔
135	if args is not None:	6✔
136	self.args.update(args)	×
137	instruction_list = []	6✔
138
139	# compile gates
140	for gate in gates:	6✔
141	if gate.name not in self.gate_compiler:	6✔
142	raise ValueError("Unsupported gate %s" % gate.name)	×
143	instruction = self.gate_compiler[gate.name](gate, self.args)	6✔
144	if instruction is None:	6✔
145	continue # neglecting global phase gate	6✔
146	instruction_list += instruction	6✔
147	if not instruction_list:	6✔
148	return None, None	×
149
150	# schedule
151	# scheduled_start_time:
152	# An ordered list of the start_time for each pulse,
153	# corresponding to gates in the instruction_list.
154	# instruction_list reordered according to the scheduled result
155	instruction_list, scheduled_start_time = self._schedule(	6✔
156	instruction_list, schedule_mode
157	)
158
159	# An instruction can be composed from several different pulse elements.
160	# We separate them an assign them to each pulse index.
161	pulse_ind_map = {}	6✔
162	next_pulse_ind = 0	6✔
163	pulse_instructions = []	6✔
164	for instruction, start_time in zip(	6✔
165	instruction_list, scheduled_start_time
166	):
167	for pulse_name, coeff in instruction.pulse_info:	6✔
168	if pulse_name not in pulse_ind_map:	6✔
169	pulse_instructions.append([])	6✔
170	pulse_ind_map[pulse_name] = next_pulse_ind	6✔
171	next_pulse_ind += 1	6✔
172	pulse_instructions[pulse_ind_map[pulse_name]].append(	6✔
173	(start_time, instruction.tlist, coeff)
174	)
175
176	# concatenate pulses
177	compiled_tlist, compiled_coeffs = self._concatenate_pulses(	6✔
178	pulse_instructions, scheduled_start_time, len(pulse_instructions)
179	)
180	compiled_tlist_map, compiled_coeffs_map = {}, {}	6✔
181	for key, index in pulse_ind_map.items():	6✔
182	compiled_tlist_map[key] = compiled_tlist[index]	6✔
183	compiled_coeffs_map[key] = compiled_coeffs[index]	6✔
184	return compiled_tlist_map, compiled_coeffs_map	6✔
185
186	def _schedule(self, instruction_list, schedule_mode):	6✔
187	"""
188	Schedule the instructions if required and
189	reorder instruction_list accordingly
190	"""
191	if schedule_mode:	6✔
192	scheduler = Scheduler(schedule_mode)	6✔
193	scheduled_start_time = scheduler.schedule(instruction_list)	6✔
194	time_ordered_pos = np.argsort(scheduled_start_time)	6✔
195	instruction_list = [instruction_list[i] for i in time_ordered_pos]	6✔
196	scheduled_start_time.sort()	6✔
197	else: # no scheduling
198	scheduled_start_time = [0.0]	6✔
199	for instruction in instruction_list[:-1]:	6✔
200	scheduled_start_time.append(	6✔
201	instruction.duration + scheduled_start_time[-1]
202	)
203	return instruction_list, scheduled_start_time	6✔
204
205	def _concatenate_pulses(	6✔
206	self, pulse_instructions, scheduled_start_time, num_controls
207	):
208	"""
209	Concatenate compiled pulses coefficients and tlist for each pulse.
210	If there is idling time, add zeros properly to prevent wrong spline.
211	"""
212	min_step_size = np.inf	6✔
213	# Concatenate tlist and coeffs for each control pulses
214	compiled_tlist = [[] for tmp in range(num_controls)]	6✔
215	compiled_coeffs = [[] for tmp in range(num_controls)]	6✔
216	for pulse_ind in range(num_controls):	6✔
217	last_pulse_time = 0.0	6✔
218	for start_time, tlist, coeff in pulse_instructions[pulse_ind]:	6✔
219	# compute the gate time, step size and coeffs
220	# according to different pulse mode
221	(	6✔
222	gate_tlist,
223	coeffs,
224	step_size,
225	pulse_mode,
226	) = self._process_gate_pulse(start_time, tlist, coeff)
227	min_step_size = min(step_size, min_step_size)	6✔
228
229	if abs(last_pulse_time) < step_size * 1.0e-6: # if first pulse	6✔
230	compiled_tlist[pulse_ind].append([0.0])	6✔
231	if pulse_mode == "continuous":	6✔
232	compiled_coeffs[pulse_ind].append([0.0])	6✔
233	# for discrete pulse len(coeffs) = len(tlist) - 1
234
235	# If there is idling time between the last pulse and
236	# the current one, we need to add zeros in between.
237	if np.abs(start_time - last_pulse_time) > step_size * 1.0e-6:	6✔
238	idling_tlist = self._process_idling_tlist(	6✔
239	pulse_mode, start_time, last_pulse_time, step_size
240	)
241	compiled_tlist[pulse_ind].append(idling_tlist)	6✔
242	compiled_coeffs[pulse_ind].append(	6✔
243	np.zeros(len(idling_tlist))
244	)
245
246	# Add the gate time and coeffs to the list.
247	execution_time = gate_tlist + start_time	6✔
248	last_pulse_time = execution_time[-1]	6✔
249	compiled_tlist[pulse_ind].append(execution_time)	6✔
250	compiled_coeffs[pulse_ind].append(coeffs)	6✔
251
252	final_time = np.max([tlist[-1] for tlist in compiled_tlist])	6✔
253	for pulse_ind in range(num_controls):	6✔
254	if not compiled_tlist[pulse_ind]:	6✔
NEW 255	continue	×
256	last_pulse_time = compiled_tlist[pulse_ind][-1][-1]	6✔
257	if np.abs(final_time - last_pulse_time) > min_step_size * 1.0e-6:	6✔
258	idling_tlist = self._process_idling_tlist(	6✔
259	pulse_mode, final_time, last_pulse_time, min_step_size
260	)
261	compiled_tlist[pulse_ind].append(idling_tlist)	6✔
262	compiled_coeffs[pulse_ind].append(np.zeros(len(idling_tlist)))	6✔
263
264	for i in range(num_controls):	6✔
265	if not compiled_coeffs[i]:	6✔
266	compiled_tlist[i] = None	×
267	compiled_coeffs[i] = None	×
268	else:
269	compiled_tlist[i] = np.concatenate(compiled_tlist[i])	6✔
270	compiled_coeffs[i] = np.concatenate(compiled_coeffs[i])	6✔
271	return compiled_tlist, compiled_coeffs	6✔
272
273	def _process_gate_pulse(self, start_time, tlist, coeff):	6✔
274	# compute the gate time, step size and coeffs
275	# according to different pulse mode
276	if np.isscalar(tlist):	6✔
277	pulse_mode = "discrete"	6✔
278	# a single constant rectanglar pulse, where
279	# tlist and coeff are just float numbers
280	step_size = tlist	6✔
281	coeff = np.array([coeff])	6✔
282	gate_tlist = np.array([tlist])	6✔
283	elif len(tlist) - 1 == len(coeff):	6✔
284	# discrete pulse
285	pulse_mode = "discrete"	×
286	step_size = tlist[1] - tlist[0]	×
287	coeff = np.asarray(coeff)	×
288	gate_tlist = np.asarray(tlist)[1:] # first t always 0 by def	×
289	elif len(tlist) == len(coeff):	6✔
290	# continuos pulse
291	pulse_mode = "continuous"	6✔
292	step_size = tlist[1] - tlist[0]	6✔
293	coeff = np.asarray(coeff)[1:]	6✔
294	gate_tlist = np.asarray(tlist)[1:]	6✔
295	else:
296	raise ValueError("The shape of the compiled pulse is not correct.")	×
297	return gate_tlist, coeff, step_size, pulse_mode	6✔
298
299	def _process_idling_tlist(	6✔
300	self, pulse_mode, start_time, last_pulse_time, step_size
301	):
302	idling_tlist = []	6✔
303	if pulse_mode == "continuous":	6✔
304	# We add sufficient number of zeros at the begining
305	# and the end of the idling to prevent wrong cubic spline.
306	if start_time - last_pulse_time > 3 * step_size:	6✔
307	idling_tlist1 = np.linspace(	6✔
308	last_pulse_time + step_size / 5,
309	last_pulse_time + step_size,
310	5,
311	)
312	idling_tlist2 = np.linspace(	6✔
313	start_time - step_size, start_time, 5
314	)
315	idling_tlist.extend([idling_tlist1, idling_tlist2])	6✔
316	else:
317	idling_tlist.append(	×
318	np.arange(
319	last_pulse_time + step_size, start_time, step_size
320	)
321	)
322	elif pulse_mode == "discrete":	6✔
323	# idling until the start time
324	idling_tlist.append([start_time])	6✔
325	return np.concatenate(idling_tlist)	6✔
326
327	@classmethod	6✔
328	def generate_pulse_shape(cls, shape, num_samples, maximum=1.0, area=1.0):	6✔
329	"""
330	Return a tuple consisting of a coeff list and a time sequence
331	according to a given pulse shape.
332
333	Parameters
334	----------
335	shape : str
336	The name ``"rectangular"`` for constant pulse or
337	the name of a Scipy window function.
338	See
339	`the Scipy documentation
340	<https://docs.scipy.org/doc/scipy/reference/signal.windows.html>`_
341	for detail.
342	num_samples : int
343	The number of the samples of the coefficients.
344	maximum : float, optional
345	The maximum of the coefficients.
346	The absolute value will be used if negative.
347	area : float, optional
348	The total area if one integrates coeff as a function of the time.
349	If the area is negative, the pulse is flipped vertically
350	(i.e. the pulse is multiplied by the sign of the area).
351
352	Returns
353	-------
354	coeff, tlist :
355	If the default window ``"shape"="rectangular"`` is used,
356	both are float numbers.
357	If Scipy window functions are used, both are a 1-dimensional numpy
358	array with the same size.
359
360	Notes
361	-----
362	If Scipy window functions are used, it is suggested to set
363	``Processor.pulse_mode`` to ``"continuous"``.
364	Notice that finite number of sampling points will also make
365	the total integral of the coefficients slightly deviate from ``area``.
366
367	Examples
368	--------
369	.. plot::
370	:context: reset
371
372	from qutip_qip.compiler import GateCompiler
373	import numpy as np
374	compiler = GateCompiler()
375	coeff, tlist= compiler.generate_pulse_shape(
376	"hann", # Scipy Hann window
377	1000, # 100 sampling point
378	maximum=3.,
379	# Notice that 2 pi is added to H by qutip solvers.
380	area= 1.,
381	)
382
383	We can plot the generated pulse shape:
384
385	.. plot::
386	:context: close-figs
387
388	import matplotlib.pyplot as plt
389	plt.plot(tlist, coeff)
390	plt.show()
391
392	The pulse is normalized to fit the area. Notice that due to
393	the finite number of sampling points, it is not exactly 1.
394
395	.. testsetup::
396
397	from qutip_qip.compiler import GateCompiler
398	import numpy as np
399	compiler = GateCompiler()
400	coeff, tlist= compiler.generate_pulse_shape(
401	"hann", # Scipy Hann window
402	1000, # 100 sampling point
403	maximum=3.,
404	# Notice that 2 pi is added to H by qutip solvers.
405	area= 1.,
406	)
407
408	.. doctest::
409
410	>>> round(np.trapz(coeff, tlist), 2)
411	1.0
412	"""
413	coeff, tlist = _normalized_window(shape, num_samples)	6✔
414	sign = np.sign(area)	6✔
415	coeff = np.abs(maximum) sign	6✔
416	tlist *= abs(area) / np.abs(maximum)	6✔
417	return coeff, tlist	6✔
418
419
420	_default_window_t_max = {	6✔
421	"boxcar": 1.0,
422	"triang": 2.0,
423	"blackman": 1.0 / 0.42,
424	"hamming": 1.0 / 0.54,
425	"hann": 2.0,
426	"bartlett": 2.0,
427	"flattop": 1.0 / 0.21557897160000217,
428	"parzen": 1.0 / 0.375,
429	"bohman": 1.0 / 0.4052847750978287,
430	"blackmanharris": 1.0 / 0.35875003586900384,
431	"nuttall": 1.0 / 0.36358193632191405,
432	"barthann": 2.0,
433	"cosine": np.pi / 2.0,
434	}
435
436
437	def _normalized_window(shape, num_samples):	6✔
438	"""
439	Normalized SciPy window functions.
440	The SciPy implementation only makes sure that it is maximum is 1.
441	Here, we save a default t_max so that the integral is always 1.
442	"""
443	if shape == "rectangular":	6✔
444	return 1.0, 1.0	6✔
445	t_max = _default_window_t_max.get(shape, None)	6✔
446	if t_max is None:	6✔
447	raise ValueError(f"Window function {shape} is not supported.")	×
448	coeff = signal.windows.get_window(shape, num_samples)	6✔
449	tlist = np.linspace(0, t_max, num_samples)	6✔
450	return coeff, tlist	6✔

qutip / qutip-qip / 2523398954

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous