def setUp(self) -> None:
        """Setup."""
        super().setUp()

        self.qubit = list(qiskit.QuantumRegister(1))[0]

        self.u1 = types.ScheduledGate(t0=100,
                                      operand=library.U1Gate(0),
                                      duration=0,
                                      bits=[self.qubit],
                                      bit_position=0)

        self.u3 = types.ScheduledGate(t0=100,
                                      operand=library.U3Gate(0, 0, 0),
                                      duration=20,
                                      bits=[self.qubit],
                                      bit_position=0)

        self.delay = types.ScheduledGate(t0=100,
                                         operand=Delay(20),
                                         duration=20,
                                         bits=[self.qubit],
                                         bit_position=0)

        style = stylesheet.QiskitTimelineStyle()
        self.formatter = style.formatter
    def setUp(self) -> None:
        """Setup."""
        super().setUp()

        self.qubits = list(qiskit.QuantumRegister(2))
        self.clbits = list(qiskit.ClassicalRegister(2))

        self.instructions = [
            types.ScheduledGate(t0=0, operand=library.U1Gate(0),
                                duration=0, bits=[self.qubits[0]], bit_position=0),
            types.ScheduledGate(t0=0, operand=library.U2Gate(0, 0),
                                duration=10, bits=[self.qubits[0]], bit_position=0),
            types.ScheduledGate(t0=10, operand=library.CXGate(),
                                duration=50, bits=[self.qubits[0], self.qubits[1]],
                                bit_position=0),
            types.ScheduledGate(t0=100, operand=library.U3Gate(0, 0, 0),
                                duration=20, bits=[self.qubits[0]], bit_position=0),
            types.ScheduledGate(t0=120, operand=library.Barrier(2),
                                duration=0, bits=[self.qubits[0], self.qubits[1]],
                                bit_position=0),
            types.ScheduledGate(t0=120, operand=library.CXGate(),
                                duration=50, bits=[self.qubits[1], self.qubits[0]],
                                bit_position=1),
            types.ScheduledGate(t0=200, operand=library.Barrier(1),
                                duration=0, bits=[self.qubits[0]], bit_position=0),
            types.ScheduledGate(t0=200, operand=library.Measure(),
                                duration=100, bits=[self.qubits[0], self.clbits[0]],
                                bit_position=0),
        ]
    def load_program(cls, scheduled_circuit: circuit.QuantumCircuit,
                     bit: types.Bits):
        """Build new BitEvents from scheduled circuit.

        Args:
            scheduled_circuit: Scheduled circuit object to draw.
            bit: Target bit object.

        Returns:
            BitEvents: New `BitEvents` object.

        Raises:
            VisualizationError: When the circuit is not transpiled with duration.
        """
        t0 = 0
        tf = scheduled_circuit.qubit_stop_time(bit)

        instructions = []
        for inst, qargs, cargs in scheduled_circuit.data:
            associated_bits = qargs + cargs
            if bit not in associated_bits:
                continue

            duration = inst.duration
            if duration is None:
                raise VisualizationError(
                    "Instruction {oper} has no duration. "
                    "You need to transpile the QuantumCircuit with "
                    "gate durations before drawing.".format(oper=inst))

            instructions.append(
                types.ScheduledGate(
                    t0=t0,
                    operand=inst,
                    duration=duration,
                    bits=associated_bits,
                    bit_position=associated_bits.index(bit),
                ))
            t0 += duration

        return BitEvents(bit, instructions, tf)
Example #4
0
    def test_gate_output(self):
        """Test gate output."""
        bit_event = events.BitEvents(self.qubits[0], self.instructions, 300)

        gates = list(bit_event.get_gates())
        ref_list = [
            types.ScheduledGate(
                t0=0, operand=library.U1Gate(0), duration=0, bits=[self.qubits[0]], bit_position=0
            ),
            types.ScheduledGate(
                t0=0,
                operand=library.U2Gate(0, 0),
                duration=10,
                bits=[self.qubits[0]],
                bit_position=0,
            ),
            types.ScheduledGate(
                t0=10,
                operand=library.CXGate(),
                duration=50,
                bits=[self.qubits[0], self.qubits[1]],
                bit_position=0,
            ),
            types.ScheduledGate(
                t0=100,
                operand=library.U3Gate(0, 0, 0),
                duration=20,
                bits=[self.qubits[0]],
                bit_position=0,
            ),
            types.ScheduledGate(
                t0=120,
                operand=library.CXGate(),
                duration=50,
                bits=[self.qubits[1], self.qubits[0]],
                bit_position=1,
            ),
            types.ScheduledGate(
                t0=200,
                operand=library.Measure(),
                duration=100,
                bits=[self.qubits[0], self.clbits[0]],
                bit_position=0,
            ),
        ]

        self.assertListEqual(gates, ref_list)
Example #5
0
    def load_program(cls,
                     scheduled_circuit: circuit.QuantumCircuit,
                     bit: types.Bits):
        """Build new BitEvents from scheduled circuit.

        Args:
            scheduled_circuit: Scheduled circuit object to draw.
            bit: Target bit object.

        Returns:
            BitEvents: New `BitEvents` object.

        Raises:
            VisualizationError: When the circuit is not transpiled with duration.
        """
        dag = circuit_to_dag(scheduled_circuit)
        nodes = list(dag.topological_op_nodes())

        t0 = 0
        instructions = []
        for node in nodes:
            associated_bits = node.qargs + node.cargs
            if bit not in associated_bits:
                continue

            duration = node.op.duration
            if duration is None:
                raise VisualizationError('Instruction {oper} has no duration. '
                                         'You need to transpile the QuantumCircuit with '
                                         'gate durations before drawing.'.format(oper=node.op))

            instructions.append(types.ScheduledGate(t0=t0,
                                                    operand=node.op,
                                                    duration=duration,
                                                    bits=associated_bits,
                                                    bit_position=associated_bits.index(bit)))
            t0 += duration

        return BitEvents(bit, instructions)
Example #6
0
    def load_program(self, program: circuit.QuantumCircuit):
        """Load quantum circuit and create drawing..

        Args:
            program: Scheduled circuit object to draw.

        Raises:
           VisualizationError: When circuit is not scheduled.
        """
        not_gate_like = (circuit.Barrier, )

        if getattr(program, "_op_start_times") is None:
            # Run scheduling for backward compatibility
            from qiskit import transpile
            from qiskit.transpiler import InstructionDurations, TranspilerError

            warnings.warn(
                "Visualizing un-scheduled circuit with timeline drawer has been deprecated. "
                "This circuit should be transpiled with scheduler though it consists of "
                "instructions with explicit durations.",
                DeprecationWarning,
            )

            try:
                program = transpile(
                    program,
                    scheduling_method="alap",
                    instruction_durations=InstructionDurations())
            except TranspilerError as ex:
                raise VisualizationError(
                    f"Input circuit {program.name} is not scheduled and it contains "
                    "operations with unknown delays. This cannot be visualized."
                ) from ex

        for t0, instruction in zip(program.op_start_times, program.data):
            bits = list(instruction.qubits) + list(instruction.clbits)
            for bit_pos, bit in enumerate(bits):
                if not isinstance(instruction.operation, not_gate_like):
                    # Generate draw object for gates
                    gate_source = types.ScheduledGate(
                        t0=t0,
                        operand=instruction.operation,
                        duration=instruction.operation.duration,
                        bits=bits,
                        bit_position=bit_pos,
                    )
                    for gen in self.generator["gates"]:
                        obj_generator = partial(gen, formatter=self.formatter)
                        for datum in obj_generator(gate_source):
                            self.add_data(datum)
                    if len(bits) > 1 and bit_pos == 0:
                        # Generate draw object for gate-gate link
                        line_pos = t0 + 0.5 * instruction.operation.duration
                        link_source = types.GateLink(
                            t0=line_pos,
                            opname=instruction.operation.name,
                            bits=bits)
                        for gen in self.generator["gate_links"]:
                            obj_generator = partial(gen,
                                                    formatter=self.formatter)
                            for datum in obj_generator(link_source):
                                self.add_data(datum)
                if isinstance(instruction.operation, circuit.Barrier):
                    # Generate draw object for barrier
                    barrier_source = types.Barrier(t0=t0,
                                                   bits=bits,
                                                   bit_position=bit_pos)
                    for gen in self.generator["barriers"]:
                        obj_generator = partial(gen, formatter=self.formatter)
                        for datum in obj_generator(barrier_source):
                            self.add_data(datum)

        self.bits = list(program.qubits) + list(program.clbits)
        for bit in self.bits:
            for gen in self.generator["bits"]:
                # Generate draw objects for bit
                obj_generator = partial(gen, formatter=self.formatter)
                for datum in obj_generator(bit):
                    self.add_data(datum)

        # update time range
        t_end = max(program.duration,
                    self.formatter["margin.minimum_duration"])
        self.set_time_range(t_start=0, t_end=t_end)