gdJ>dZddlmZddlZddlZddlmZddlmZddlm Z ddl Z ddl m ZmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZejrddlm Z d:dZ!d;dZ"ddZ%d?dZ&d>dZ'd>dZ( d@dAd,Z)dBd0Z* dCdDd9Z+dS)EzZBasic rescheduling functions which take schedule or instructions and return new schedules.) annotationsN) defaultdict)Iterable)Type)channels exceptions instructions)ClassicalIOChannel) PulseError)UnassignedDurationError)InstructionScheduleMap) directives)Schedule ScheduleBlockScheduleComponent)Pulseblockrreturnrc |stdtj|}|jD]}t |t rt|}t|j drC|j j |j z }|dkr(td|j d|j d|j dnd}| |d |dkr=tj|j}| ||d | |d |j |S) aConvert ``ScheduleBlock`` to ``Schedule``. Args: block: A ``ScheduleBlock`` to convert. Returns: Scheduled pulse program. Raises: UnassignedDurationError: When any instruction duration is not assigned. PulseError: When the alignment context duration is shorter than the schedule duration. .. note:: This transform may insert barriers in between contexts. zAll instruction durations should be assigned before creating `Schedule`.Please check `.parameters` to find unassigned parameter objects.durationrzScheduleBlock z9 has longer duration than the specified context duration z > .Tinplace)is_schedulabler rinitialize_fromblocks isinstancerblock_to_schedulehasattralignment_contextrr nameappendr RelativeBarrierrshiftalign)rscheduleop_datacontext_schedule post_buffercontext_boundarys ^/granary/edev/quantum/lib/python3.11/site-packages/qiskit/pulse/transforms/canonicalization.pyrr"s    ! ! % O   '..H<33 g} - - 3099 w0*== %7@CSC\\ ??$MMM+4MM9@9IMMM# OO,dO ; ; ;Q#/#?AQ#R  0 6 6{ C CTRRR OOGTO 2 2 2 2  " ( ( 2 22 scheduleslist[Schedule]c g}g}|D]}tj|}|jD]\}}t|tjr|j|vrY||j}||}||tj||j|j d| |j|||d|||d| ||S)zOptimization pass to replace identical pulses. Args: schedules: Schedules to compress. Returns: Compressed schedules. Tr) rrr rPlaypulseindexinsertchannelr!r") r-existing_pulses new_schedulesr& new_scheduletimeinstidxidentical_pulses r+compress_pulsesr<Us3$&OM++/99 "/ > >JD$$ 122 >:00)// ;;C&5c&:O ''$)/4<SS $( $**4:666 ''dD'AAAA##D$#====\**** r,programct|tr;tj|}|jD]\}}|||d|St d|jjd)a Flatten (inline) any called nodes into a Schedule tree with no nested children. Args: program: Pulse program to remove nested structure. Returns: Flatten pulse program. Raises: PulseError: When invalid data format is given. TrzInvalid input program  is specified.)rrrr r3r __class____name__)r= flat_schedr8r9s r+flattenrCys'8$$^-g66 !. 8 8JD$   dD$  7 7 7 7\'2C2L\\\]]]r,Schedule | ScheduleBlockct|trt|St|trt |St d|jjd)aRecursively remove call instructions and inline the respective subroutine instructions. Assigned parameter values, which are stored in the parameter table, are also applied. The subroutine is copied before the parameter assignment to avoid mutation problem. Args: program: A program which may contain the subroutine, i.e. ``Call`` instruction. Returns: A schedule without subroutine. Raises: PulseError: When input program is not valid data format. zInvalid program r?)rr_inline_scheduler _inline_blockr r@rA)r=s r+inline_subroutinesrHsf'8$$X((( G] + +XW%%%VG,=,FVVVWWWr,r&ctj|}|jD]Z\}}t|tr(t |}|||dB|||d[|S)zA helper function to inline subroutine of schedule. .. note:: If subroutine is ``ScheduleBlock`` it is converted into Schedule to get ``t0``. Tr)rrchildrenrrFr3)r& ret_schedulet0r9inline_schedules r+rFrFs +H55L%88D dH % % 8.t44O   OT  B B B B   D$  7 7 7 7 r,ctj|}|jD]U}t|tr't |}||d>||dV|S)zA helper function to inline subroutine of schedule block. .. note:: If subroutine is ``Schedule`` the function raises an error. Tr)rrrrrGr")r ret_blockr9 inline_blocks r+rGrGs -e44I 11 dM * * 1(..L   \4  8 8 8 8   T4  0 0 0 0 r,cD|tjgS)zRemove directives. Args: schedule: A schedule to remove compiler directives. Returns: A schedule without directives. )instruction_types)excluder Directive)r&s r+remove_directivesrUs!   z/C.D  E EEr,c2d}||S)zRemove trivial barriers with 0 or 1 channels. Args: schedule: A schedule to remove trivial barriers. Returns: schedule: A schedule without trivial barriers c~t|dtjot|djdkS)N)rrr#lenr)r9s r+ filter_funcz,remove_trivial_barriers..filter_funcs3$q':#=>>\3tAwGWCXCX[\C\\r,)rS)r&r[s r+remove_trivial_barriersr\s*]]]   K ( ((r,u3TIterable[ScheduleComponent]inst_mapInstructionScheduleMap | Nonecal_gatestrmax_calibration_duration int | None align_time align_all bool | Nonecd}d}||dkrtjd||}d|D} | ||r |||}nd}t|g| R}g} t|D]\} } t j| } | j}|r|| r || | z }n||z }nd}| jD]u\}}d|jD}|r(|| tfd|D}||z }|dkrtj d | ||z|d v| | | S) aS Return new schedules where measurements occur at the same physical time. This transformation will align the first :class:`.Acquire` on every channel to occur at the same time. Minimum measurement wait time (to allow for calibration pulses) is enforced and may be set with ``max_calibration_duration``. By default only instructions containing a :class:`.AcquireChannel` or :class:`.MeasureChannel` will be shifted. If you wish to keep the relative timing of all instructions in the schedule set ``align_all=True``. This method assumes that ``MeasureChannel(i)`` and ``AcquireChannel(i)`` correspond to the same qubit and the acquire/play instructions should be shifted together on these channels. .. code-block:: from qiskit import pulse from qiskit.pulse import transforms d0 = pulse.DriveChannel(0) m0 = pulse.MeasureChannel(0) a0 = pulse.AcquireChannel(0) mem0 = pulse.MemorySlot(0) sched = pulse.Schedule() sched.append(pulse.Play(pulse.Constant(10, 0.5), d0), inplace=True) sched.append(pulse.Play(pulse.Constant(10, 1.), m0).shift(sched.duration), inplace=True) sched.append(pulse.Acquire(20, a0, mem0).shift(sched.duration), inplace=True) sched_shifted = sched << 20 aligned_sched, aligned_sched_shifted = transforms.align_measures([sched, sched_shifted]) assert aligned_sched == aligned_sched_shifted If it is desired to only shift acquisition and measurement stimulus instructions set the flag ``align_all=False``: .. code-block:: aligned_sched, aligned_sched_shifted = transforms.align_measures( [sched, sched_shifted], align_all=False, ) assert aligned_sched != aligned_sched_shifted Args: schedules: Collection of schedules to be aligned together inst_map: Mapping of circuit operations to pulse schedules cal_gate: The name of the gate to inspect for the calibration time max_calibration_duration: If provided, inst_map and cal_gate will be ignored align_time: If provided, this will be used as final align time. align_all: Shift all instructions in the schedule such that they maintain their relative alignment with the shifted acquisition instruction. If ``False`` only the acquisition and measurement pulse instructions will be shifted. Returns: The input list of schedules transformed to have their measurements aligned. Raises: PulseError: If the provided alignment time is negative. c,g}|D]}t}td}|jD]Q\}}t|tjr2|j|vr)||j|||jj<R|||S)z7Return a list of first acquire times for each schedule.cdSNrlr,r+zAalign_measures..get_first_acquire_times..3sDr,) setrr rAcquirer4addr2r")r- acquire_timesr&visited_channelsqubit_first_acquire_timesr8r9s r+get_first_acquire_timesz/align_measures..get_first_acquire_times.s ! < b>b$((666DH-dl.@A  !: ; ; ; ;r,cd}||D]D}|||tjdtj}t |j|}E|S)zNReturn the time needed to allow for readout discrimination calibration pulses.r)qubits_with_instructiongetnppimaxr)r_rarcqubitscmds r+get_max_calibration_durationz4align_measures..get_max_calibration_duration=sb$% 66x@@ S SF,,x25AAC'*3<9Q'R'R $ $''r,NrzAlign time cannot be negative.cLg|]!}tdg|R"S)r)rzvalues).0timess r+ z"align_measures..Ls0RRRUQ0000RRRr,chh|]/}t|tjtjf(|j0Srl)rchansMeasureChannelAcquireChannelr2)rchans r+ z!align_measures..dsE$$$dU%95;O$PQQ$ $$$r,c30K|]}|v|VdSrkrl)rrsched_first_acquire_timess r+ z!align_measures..ks@%%888.d38888%%r,zThe provided alignment time is scheduling an acquire instruction earlier than it was scheduled for in the original Schedule. This may result in an instruction being scheduled before t=0 and an error being raised.Tr) rr rz enumeraterr stop_timer rwarningswarnr3r")r-r_rarcrerfrtr}first_acquire_timesmax_acquire_timesr6 sched_idxr&r7rr$r8r9measurement_channelsmax_start_timers @r+align_measuresrsV   (((*q..#$DEEE11)<<SR>QRRR # + -+G+GRZ+[+[((+,(1F4EFFF M(33$+$+ 8/99 &  "9- /"%6y%AA"Y.E"/ B BJD$$$ M$$$ $ 4,? ,J)!$%%%% 4%%%"" #^3qyy -   u dD  A A A A\**** r,rmeas_maplist[list[int]]c tj|}i}|jD]J\}}t|tjr|jr.|jj|jjkrtj dg}|D]%}|jj|vr| |&|D]}tj|j tj |tj||j|j} ||vr||| d||hi}p|||vr3||| d|||2|||dL|S)aReturn a new schedule with implicit acquires from the measurement mapping replaced by explicit ones. .. warning:: Since new acquires are being added, Memory Slots will be set to match the qubit index. This may overwrite your specification. Args: schedule: Schedule to be aligned. meas_map: List of lists of qubits that are measured together. Returns: A ``Schedule`` with the additional acquisition instructions. zrOne of your acquires was mapped to a memory slot which didn't match the qubit index. I'm relabeling them to match.)mem_slotkernel discriminatorTr)rrr rrorr2r4rrextendrrr MemorySlotrrr3rp) r&rr7 acquire_mapr8r9 all_qubitssublisti explicit_insts r+add_implicit_acquiresrs+H55LK+:: d dL0 1 1 :} !4 8J!J!J F J# / /<%00%%g... - - , 4M(++"-a00;"&"4 !!! {** ''mT'JJJ#'!+KKk$/// ''mT'JJJ%))!,,, -   dD  9 9 9 9 r,FrIterable[chans.Channel] | Noneuntilrboolpad_with%Type[instructions.Instruction] | Nonec |p|j}|p|j}|r:t|tjr|}n)t d|jjdtj}|D]}t|tr||jvr,| dtj|||}Nd}t|j |}g} ||krt t|\} } n*#t$r| |||z fYn:wxYw|| kr(| |t#| ||z f| }||kt| D]'\} } | | || ||}(|S)a0Pad the input Schedule with ``Delay``s on all unoccupied timeslots until ``schedule.duration`` or ``until`` if not ``None``. Args: schedule: Schedule to pad. channels: Channels to pad. Defaults to all channels in ``schedule`` if not provided. If the supplied channel is not a member of ``schedule`` it will be added. until: Time to pad until. Defaults to ``schedule.duration`` if not provided. inplace: Pad this schedule by mutating rather than returning a new schedule. pad_with: Pulse ``Instruction`` subclass to be used for padding. Default to :class:`~qiskit.pulse.instructions.Delay` instruction. Returns: The padded schedule. Raises: PulseError: When non pulse instruction is set to `pad_with`. 'z-' is not valid pulse instruction to pad with.rr)rr issubclassr Instructionr r@rADelayrr r3iter timeslotsnext StopIterationr"min) r&rrrrpad_clsr4 prev_timerto_padrLt1rs r+padrs4  &X&E,8,H% h 8 9 9 GG^H&/^^^ $XX g1 2 2   (+ + +q,*rsKa`"""""" ######$$$$$$DDDDDDDDDD444444......;;;;;;HHHHHH000000LLLLLLLLLL +******03030303f!!!!H^^^^*XXXX.$     F F F F ) ) ) )$/3+/!! ZZZZZz1111l046: >>>>>>>r,