g6 dZddlmZddlZddlmZmZddlZddl m Z m Z ddl m Z ddlmZmZddlmZGd d ejZGd d eZGd deZGddeZGddeZGddeZdS)zXA collection of passes to reallocate the timeslots of instructions according to context.) annotationsN)CallableTuple)ParameterExpressionParameterValueType) PulseError)ScheduleScheduleComponent)instruction_duration_validationc|eZdZdZddZejddZeejdd Z dd Z dZ dS) AlignmentKindz)An abstract class for schedule alignment.context_paramsTuple[ParameterValueType, ...]c.t||_dS)zCreate new context.N)tuple_context_params)selfrs X/granary/edev/quantum/lib/python3.11/site-packages/qiskit/pulse/transforms/alignments.py__init__zAlignmentKind.__init__s$^44scheduler returncdS)=Reallocate instructions according to the policy. Only top-level sub-schedules are aligned. If sub-schedules are nested, nested schedules are not recursively aligned. Args: schedule: Schedule to align. Returns: Schedule with reallocated instructions. N)rrs ralignzAlignmentKind.align s  rboolcdS)u#Return ``True`` if this is sequential alignment context. This information is used to evaluate DAG equivalency of two :class:`.ScheduleBlock`s. When the context has two pulses in different channels, a sequential context subtype intends to return following scheduling outcome. .. code-block:: text ┌────────┐ D0: ┤ pulse1 ├──────────── └────────┘ ┌────────┐ D1: ────────────┤ pulse2 ├ └────────┘ On the other hand, parallel context with ``is_sequential=False`` returns .. code-block:: text ┌────────┐ D0: ┤ pulse1 ├ ├────────┤ D1: ┤ pulse2 ├ └────────┘ All subclasses must implement this method according to scheduling strategy. Nrrs r is_sequentialzAlignmentKind.is_sequential/s : rotherobjectcjt|t|urdS|j|jkrdSdS)z!Check equality of two transforms.FT)typer)rr!s r__eq__zAlignmentKind.__eq__Ns9 ::T%[[ ( (5  5#8 8 85trcV|jjdd|jdS)N(z, )) __class____name__joinrrs r__repr__zAlignmentKind.__repr__Vs-.)NNDIId6J,K,KNNNNrN)rrrr rr rr)r!r"rr) r* __module__ __qualname____doc__rabcabstractmethodrpropertyr r%r,rrrr r s335555          X :OOOOOrr cZeZdZdZfdZed dZddZedd Z xZ S) AlignLeftztAlign instructions in as-soon-as-possible manner. Instructions are placed at earliest available timeslots. cLtddS)z"Create new left-justified context.rrNsuperrrr)s rrzAlignLeft.__init__`$ +++++rrrcdSNFrrs rr zAlignLeft.is_sequentialdurrr cttj|}|jD]\}}||||Sr)r initialize_fromchildren_push_left_appendrraligned_childs rrzAlignLeft.alignhsH*844 ) 3 3HAu  " "7E 2 2 2 2rthisr!r ctj}tj}t||z}fd|D}|rF|tj|}||z }nd}j||z }t||} | dS)aCReturn ``this`` with ``other`` inserted at the maximum time over all channels shared between ```this`` and ``other``. Args: this: Input schedule to which ``other`` will be inserted. other: Other schedule to insert. Returns: Push left appended schedule. cvg|]5}j|z |z6Sr) stop_time ch_stop_time ch_start_time.0channelr!rIs r z/AlignLeft._push_left_append..sQ    NT..w77 7%:M:Mg:V:V V   rrTinplace) setchannelslistnpargminrMrNmaxinsert) rIr! this_channelsother_channelsshared_channels ch_slacks slack_chanshared_insert_timeother_only_insert_time insert_times `` rrDzAlignLeft._push_left_appendzsDM** U^,,}~=>>     *    #(9)=)=>J!%!2!2:!>!>ATATU_A`A`!`  !" "5!4~ 7U!W,.DEE {{;t{<<rrs rr zAlignRight.is_sequentialr?rrr ctj|}t|jD]\}}|||}|SrA)r rBreversedrC_push_right_prependrEs rrzAlignRight.alignsN*844 !233 ? ?HAu..w>>GGrrIr!r ctj}tj}t||z}fd|D}|rt|jz}njjz jz}|dkr1| dddn|dS)aReturn ``this`` with ``other`` inserted at the latest possible time such that ``other`` ends before it overlaps with any of ``this``. If required ``this`` is shifted to start late enough so that there is room to insert ``other``. Args: this: Input schedule to which ``other`` will be inserted. other: Other schedule to insert. Returns: Push right prepended schedule. cfg|]-}||z .Sr)rNrMrOs rrRz2AlignRight._push_right_prepend..sG   JQD  w ' '%*<*>     Ud     Ni..5+;;KK.5?:U=MMK ?? JJ |TJ 2 2 2 KK5$K / / / / KK UDK 9 9 9 rr.r-rd) r*r/r0r1rr4r rrernrfrgs@rriris ,,,,,X$   \     rricBeZdZdZfdZed dZd dZxZS) AlignSequentialzAlign instructions sequentially. Instructions played on different channels are also arranged in a sequence. No buffer time is inserted in between instructions. cLtddS)zCreate new sequential context.rr8Nr9r;s rrzAlignSequential.__init__r<rrrcdSNTrrs rr zAlignSequential.is_sequentialtrrr ctj|}|jD]"\}}||j|d#|S)rTrS)r rBrCr[durationrEs rrzAlignSequential.alignsO*844 ) B BHAu NN7+UDN A A A Arr.r-) r*r/r0r1rr4r rrfrgs@rrurusv ,,,,,XrrucZeZdZdZd fd Zed dZedZdd ZxZ S)AlignEquispacedzAlign instructions with equispaced interval within a specified duration. Instructions played on different channels are also arranged in a sequence. This alignment is convenient to create dynamical decoupling sequences such as PDD. r{int | ParameterExpressioncNt|fdS)aoCreate new equispaced context. Args: duration: Duration of this context. This should be larger than the schedule duration. If the specified duration is shorter than the schedule duration, no alignment is performed and the input schedule is just returned. This duration can be parametrized. r8Nr9)rr{r)s rrzAlignEquispaced.__init__ s(  44444rrrcdSrxrrs rr zAlignEquispaced.is_sequentialryrc|jdSzReturn context duration.rrrs rr{zAlignEquispaced.duration#A&&rrr c0t|jtd|jD}|j|kr|S|j|z }t |jdkr.t j|t |jdz \}}nd}|}t j|d\}}tj|}t|j |z|z}|jD]4\} } | || dt|j |z}5|S)rc3*K|]\}}|jVdS)N)r{)rPrGrHs r z(AlignEquispaced.align..,s(NN5U^NNNNNNrrTrS) r r{sumrClenrXdivmodr rBintrLr[) rrtotal_duration total_delayintervalmoddelayrF_t0rGrHs rrzAlignEquispaced.aligns% ( 666NNH ) )Omn4 x ! !A % %Ik3x7H3I3IA3MNNMHccHCYsA&& s*844'#e+c122 ) 4 4HAu NN3tN 4 4 4g'(233CCr)r{r~r.r-) r*r/r0r1rr4r r{rrfrgs@rr}r}s 5 5 5 5 5 5X''X'''''''''rr}cpeZdZdZdfd Zedd Zed Zed ZddZ xZ S) AlignFuncaAllocate instructions at position specified by callback function. The position is specified for each instruction of index ``j`` as a fractional coordinate in [0, 1] within the specified duration. Instructions played on different channels are also arranged in a sequence. This alignment is convenient to create dynamical decoupling sequences such as UDD. For example, UDD sequence with 10 pulses can be specified with following function. .. code-block:: python import numpy as np def udd10_pos(j): return np.sin(np.pi*j/(2*10 + 2))**2 .. note:: This context cannot be QPY serialized because of the callable. If you use this context, your program cannot be saved in QPY format. r{r~funcrcPt||fdS)abCreate new equispaced context. Args: duration: Duration of this context. This should be larger than the schedule duration. If the specified duration is shorter than the schedule duration, no alignment is performed and the input schedule is just returned. This duration can be parametrized. func: A function that takes an index of sub-schedule and returns the fractional coordinate of of that sub-schedule. The returned value should be defined within [0, 1]. The pulse index starts from 1. r8Nr9)rr{rr)s rrzAlignFunc.__init__as+ 4(899999rrrcdSrxrrs rr zAlignFunc.is_sequentialoryrc|jdSrrrs rr{zAlignFunc.durationsrrc|jdS)z"Return context alignment function.rrrs rrzAlignFunc.funcxrrrr ct|j|j|jkr|Stj|}t |jD]\}\}}|j||dzz}t|d|jzz }|dks ||jkrtd|d|| ||d|S)rrg?rzInvalid schedule position t=z is specified at index=TrS) r r{r rB enumeraterCrrrr[)rrrFindrGrH _t_centerrs rrzAlignFunc.align}s ( 666 =8, , ,O*844():;; 5 5OC!U  #'(:(::Ii#"6677CQww# -- !a!a!a\_!a!abbb NN3tN 4 4 4 4r)r{r~rrr.r-) r*r/r0r1rr4r r{rrrfrgs@rrrHs0 : : : : : :X''X'''X'rr)r1 __future__rr2typingrrnumpyrX"qiskit.circuit.parameterexpressionrrqiskit.pulse.exceptionsrqiskit.pulse.scheduler r qiskit.pulse.utilsr ABCr r6rirur}rrrrrs_^"""""" """"""""VVVVVVVV......========>>>>>>>O>O>O>O>OCG>O>O>OB@=@=@=@=@= @=@=@=FAAAAAAAAHmDBBBBBmBBBJNNNNN NNNNNr