giw:dZddlZddlZddlZddlmZddlmZddlm Z m Z m Z m Z ddl ZddlmZmZddlmZmZmZddlmZmZdd lmZdd lmZdd lmZdd lm Z m!Z!m"Z"dd l#m$Z$ddl%m&Z&ddl'm(Z(GddeZ)GddZ*GddZ+dS)zKHelper class used to convert a pulse instruction into PulseQobjInstruction.N)Enum)singledispatchmethod)UnionListIteratorOptional) ParameterParameterExpression)channels instructionslibrary)Kernel Discriminator) QiskitError)parse_string_expr)Schedule)QobjMeasurementOptionPulseLibraryItemPulseQobjInstruction) MeasLevel)deprecate_func)deprecate_pulse_dependencyc~eZdZdZdZdZdZdZdZdZ e de j d dfd Z e d ed e j fd Zd S)ParametricPulseShapeszMap the assembled pulse names to the pulse module waveforms. The enum name is the transport layer name for pulse shapes, the value is its mapping to the OpenPulse Command in Qiskit. GaussianGaussianSquareGaussianSquareDraggaussian_square_echoDragConstantinstancereturnc|t|tjr||jSt d|d)zGet Qobj name from the pulse class instance. Args: instance: SymbolicPulse class. Returns: Qobj name. Raises: QiskitError: When pulse instance is not recognizable type. 'z' is not valid pulse type.) isinstancer SymbolicPulse pulse_typer)clsr!s ^/granary/edev/quantum/lib/python3.11/site-packages/qiskit/qobj/converters/pulse_instruction.py from_instancez#ParametricPulseShapes.from_instance3sF h 5 6 6 ,3x*++ +BhBBBCCCnamecBtt||jS)zGet symbolic pulse class from the name. Args: name: Qobj name of the pulse. Returns: Corresponding class. )getattrr value)r(r,s r)to_typezParametricPulseShapes.to_typeHswD 000r+N)__name__ __module__ __qualname____doc__gaussiangaussian_squaregaussian_square_dragrdragconstant classmethodr r&r*strr0r+r)rr%s H&O/1 DHD'D !DDD[D( 13 17#8 1 1 1[ 1 1 1r+rcTeZdZdZeddddefdZded ee j e e j fd efd Z ed ed efd Zee j d ed efdZee jd ed efdZee jd ed efdZee jd ed efdZee jd ed efdZee jd ed efdZee jd ed efdZee jd ed efdZde e j d ed efdZ dS)InstructionToQobjConvertera/Converts Qiskit Pulse in-memory representation into Qobj data. This converter converts the Qiskit Pulse in-memory representation into the transfer layer format to submit the data from client to the server. The transfer layer format must be the text representation that conforms to the `OpenPulse specification`__. Extension to the OpenPulse can be achieved by subclassing this this with extra methods corresponding to each augmented instruction. For example, .. code-block:: python class MyConverter(InstructionToQobjConverter): def _convert_NewInstruction(self, instruction, time_offset): command_dict = { 'name': 'new_inst', 't0': time_offset + instruction.start_time, 'param1': instruction.param1, 'param2': instruction.param2 } return self._qobj_model(**command_dict) where ``NewInstruction`` must be a class name of Qiskit Pulse instruction. z1.2zin the 2.0 releasezThe `Qobj` class and related functionality are part of the deprecated `BackendV1` workflow, and no longer necessary for `BackendV2`. If a user workflow requires `Qobj` it likely relies on deprecated functionality and should be updated to use `BackendV2`.)sinceremoval_timelineadditional_msg qobj_modelc "||_||_dS)zCreate new converter. Args: qobj_model: Transfer layer data schema. run_config: Run configuration. N) _qobj_model _run_config)selfrB run_configs r)__init__z#InstructionToQobjConverter.__init__ps&&%r+shift instructionr"ct|tr?td|Dr|||St d|||S)a'Convert Qiskit in-memory representation to Qobj instruction. Args: instruction: Instruction data in Qiskit Pulse. Returns: Qobj instruction data. Raises: QiskitError: When list of instruction is provided except for Acquire. c3JK|]}t|tjVdSN)r%r Acquire).0insts r) z6InstructionToQobjConverter.__call__..s/RRd:dL$899RRRRRRr+)instruction_bundle time_offsetz:Bundle of instruction is not supported except for Acquire.)r%listall_convert_bundled_acquirer_convert_instruction)rFrIrJs r)__call__z#InstructionToQobjConverter.__call__s k4 ( ( \RRkRRRRR 44'2 %5Z[[ [((e<<+*?*H > > >   r+cl|jdd}g}|jr |jjg}d||jz|j|jjg|d}|tjkrk|j r;| dt|j j |j j gi|jr"| d|jjgi|tjtjfvrB|jr;| dt|jj |jj gi|jd i|S) zReturn converted `Acquire`. Args: instruction: Qiskit Pulse acquire instruction. time_offset: Offset time. Returns: Qobj instruction data. meas_levelacquire)r,t0durationqubits memory_slotdiscriminatorsr,params register_slotkernelsr<)rEgetmem_slotindex start_timer`channelr CLASSIFIED discriminatorupdaterr,rereg_slotKERNELEDkernelrD)rFrJrSr\ri command_dicts r)_convert_acquirez+InstructionToQobjConverter._convert_acquires%)),::    4#,23H 66#,"*01#    - - -( ##(1%0%>%C'2'@'G+   # U##_{7K7Q6R$STTT ),i.BC C C! ##!1%0%7%<[EWE^$ t//,///r+c^d||jz|jj|jdz d}|jdi|S)zReturn converted `SetFrequency`. Args: instruction: Qiskit Pulse set frequency instruction. time_offset: Offset time. Returns: Qobj instruction data. setfʚ;r,r_ch frequencyr<rkrlr,rzrDrFrJrSrss r)_convert_set_frequencyz1InstructionToQobjConverter._convert_set_frequencysM  66%*$.6    t//,///r+c^d||jz|jj|jdz d}|jdi|S)zReturn converted `ShiftFrequency`. Args: instruction: Qiskit Pulse shift frequency instruction. time_offset: Offset time. Returns: Qobj instruction data. shiftfrwrxr<r{r|s r)_convert_shift_frequencyz3InstructionToQobjConverter._convert_shift_frequencysM  66%*$.6    t//,///r+cXd||jz|jj|jd}|jdi|S)zReturn converted `SetPhase`. Args: instruction: Qiskit Pulse set phase instruction. time_offset: Offset time. Returns: Qobj instruction data. setpr,r_ryphaser<rkrlr,rrDr|s r)_convert_set_phasez-InstructionToQobjConverter._convert_set_phasesH  66%* &    t//,///r+cXd||jz|jj|jd}|jdi|S)zReturn converted `ShiftPhase`. Args: instruction: Qiskit Pulse shift phase instruction. time_offset: Offset time. Returns: Qobj instruction data. fcrr<rr|s r)_convert_shift_phasez/InstructionToQobjConverter._convert_shift_phase)sH  66%* &    t//,///r+cXd||jz|jj|jd}|jdi|S)zReturn converted `Delay`. Args: instruction: Qiskit Pulse delay instruction. time_offset: Offset time. Returns: Qobj instruction data. delay)r,r_ryr`r<)rkrlr,r`rDr|s r)_convert_delayz)InstructionToQobjConverter._convert_delay@sH  66%*#,    t//,///r+ct|jtjrt |jj}d|vr=d|vr9t |dtjd|dzz|d<|d=dt |jj ||j z|j j |d}n|j ||j z|j j d}|jdi|S)zReturn converted `Play`. Args: instruction: Qiskit Pulse play instruction. time_offset: Offset time. Returns: Qobj instruction data. ampangley?parametric_pulse)r, pulse_shaper_ry parameters)r,r_ryr<)r%pulser r&dictrcomplexnpexprr*r,rkrlrD)rFrJrSrerss r) _convert_playz(InstructionToQobjConverter._convert_playWs k')> ? ? ++677F7f#4#4 'u rF7O?S8T8T(T U Uu 7O+4BB;CTUUZ!K$::!).$ LL$(!K$::!).L  t//,///r+cNd||jz|j|jd}|jdi|S)zReturn converted `Snapshot`. Args: time_offset: Offset time. instruction: Qiskit Pulse snapshot instruction. Returns: Qobj instruction data. snapshot)r,r_labeltyper<)rkrrrDr|s r)_convert_snapshotz,InstructionToQobjConverter._convert_snapshot}sE  66 &$    t//,///r+rRcb|jdd}|dj}|dj}g}g}g}g} g} |D]J} || jj| j|krtd| j|krtd| jr|| jj|tj kre| j r8| t| j j | j j| jr|| jj|tjtj fvr?| jr8| t| jj | jjLd||z||d} |r|| d <|r|| d <| r=t%| } | t%|ks| d kr| | d <ntd | r=t%| }|t%|ks|d kr| | d<ntd|jdi| S)aReturn converted list of parallel `Acquire` instructions. Args: instruction_bundle: List of Qiskit Pulse acquire instruction. time_offset: Offset time. Returns: Qobj instruction data. Raises: QiskitError: When instructions are not aligned. QiskitError: When instructions have different duration. QiskitError: When discriminator or kernel is missing in a part of instructions. r\r]rzThe supplied acquire instructions have different starting times. Something has gone wrong calling this code. Please report this issue.zHAcquire instructions beginning at the same time must have same duration.rdr^)r,r_r`rarbrfrczfA discriminator must be supplied for every acquisition or a single discriminator for all acquisitions.rgzXA kernel must be supplied for every acquisition or a single kernel for all acquisitions.r<)rErhrkr`appendrlrjrrirrmrnrr,rerprqrrlenrD)rFrRrSr\r_r` memory_slotsregister_slotsrarcrgrJrsnum_discriminators num_kernelss r)rVz3InstructionToQobjConverter._convert_bundled_acquires&%)),::  " -%a(1 -& & K MM+-3 4 4 4%++! #x//!^# @##K$8$>???Y111,"))-!,!:!?#.#<#C'F"))+*>*DEEEi0)2FGGG%NN-!,!3!8ASAZ "     7*6L '  ;,:L )  !$^!4!4 !S[[004F!4K4K1? -..!:  g,,Kc&kk))[A-=-=*1 Y''!3  t//,///r+N)!r1r2r3r4rrrHintrr InstructionrrNrXrrWregisterrt SetFrequencyr}ShiftFrequencyrSetPhaser ShiftPhaserDelayrPlayrSnapshotrrVr<r+r)r>r>UsS4^-0 &( & & & &==<3T,:N5OOP=  ====4        ""<#7886060  6060609860p""<#<==00  000>=0,""<#>??00  000@?0,""<#89900  000:90,""<#:;;00  000<;0,""<#56600  000760,""<#455#0#0  #0#0#065#0J""<#89900  000:90,d0 !56d0d0  d0d0d0d0d0d0r+r>cheZdZdZejdZe ddee e fdZ de de fdZde deejfd Zde efd Zd edejfd Zed eeefdeeeffdZde deejfdZde deejfdZde deejfdZde deejfdZ de deejfdZ!de deejfdZ"de deejfdZ#de deejfdZ$de deejfdZ%dS)QobjToInstructionConverteraConverts Qobj data into Qiskit Pulse in-memory representation. This converter converts data from transfer layer into the in-memory representation of the front-end of Qiskit Pulse. The transfer layer format must be the text representation that conforms to the `OpenPulse specification`__. Extension to the OpenPulse can be achieved by subclassing this this with extra methods corresponding to each augmented instruction. For example, .. code-block:: python class MyConverter(QobjToInstructionConverter): def get_supported_instructions(self): instructions = super().get_supported_instructions() instructions += ["new_inst"] return instructions def _convert_new_inst(self, instruction): return NewInstruction(...) where ``NewInstruction`` must be a subclass of :class:`~qiskit.pulse.instructions.Instruction`. z([a-zA-Z]+)(\d+)N pulse_libraryc Ni}|D]}|j||j<||_||_dS)zCreate new converter. Args: pulse_library: Pulse library in Qobj format. run_config: Run configuration. N)samplesr,_pulse_libraryrE)rFrrGpulse_library_dictlib_items r)rHz#QobjToInstructionConverter.__init__sD % A AH080@ x} - -0%r+rJr"ct}||D]}||j|d |S)zConvert Qobj instruction to Qiskit in-memory representation. Args: instruction: Instruction data in Qobj format. Returns: Scheduled Qiskit Pulse instruction in Schedule format. T)inplace)r_get_sequencesinsertr_)rFrJschedulerPs r)rXz#QobjToInstructionConverter.__call__+sN::'' 44 @ @D OOKND$O ? ? ? ?r+c#K t|d|j}n#t$r |j}YnwxYw||Ed{VdS)aA method to iterate over pulse instructions without creating Schedule. .. note:: This is internal fast-path function, and callers other than this converter class might directly use this method to generate schedule from multiple Qobj instructions. Because __call__ always returns a schedule with the time offset parsed instruction, composing multiple Qobj instructions to create a gate schedule is somewhat inefficient due to composing overhead of schedules. Directly combining instructions with this method is much performant. Args: instruction: Instruction data in Qobj format. Yields: Qiskit Pulse instructions. :meta public: _convert_N)r.r,AttributeError_convert_generic)rFrJmethods r)rz)QobjToInstructionConverter._get_sequences9sy. +T#A{/?#A#ABBFF + + +*FFF +6+&&&&&&&&&&&s 11c gdS)z(Retrun a list of supported instructions.)r^rrrvrrrrr<)rFs r)get_supported_instructionsz5QobjToInstructionConverter.get_supported_instructionsWs    r+rlc|j|}|r|dt|d}}|tjjkrt j|S|tjjkrt j|S|tjjkrt j|Std|d)aParse and retrieve channel from ch string. Args: channel: String identifier of pulse instruction channel. Returns: Matched channel object. Raises: QiskitError: Is raised if valid channel is not matched rr]zChannel z is not valid) __chan_regex__matchgrouprr DriveChannelprefixMeasureChannelControlChannelr)rFrlrrrjs r) get_channelz&QobjToInstructionConverter.get_channelds#))'22  6!KKNNC A,?,?EF.555,U33382999.u55582999.u555;W;;;<<z@QobjToInstructionConverter.disassemble_value..s"$Z$Z$ZUIe,<,<$Z$Z$Zr+r<)r%r;rre)rstr_exprs r)disassemble_valuez,QobjToInstructionConverter.disassemble_value}sU j# & & \(UKKKH![[$Z$Z(/$Z$Z$Z[[Jr+c #4 Kj}j}d|D}fdtt|D}t dr)fdtt|D}ndgt|z}t drjnd t ts g t fdtt Drtj d d }|r$tdd d j i d j }t d rjnd t ts g t fd tt Drtj d  d }|r$tdd d j i d j }t!|||D]"\} } } t#j|| | | ||V#dS)zReturn converted `Acquire` instruction. Args: instruction: Acquire qobj Yields: Qiskit Pulse acquire instructions c6g|]}tj|Sr<)r AcquireChannel)rOqubits r) z?QobjToInstructionConverter._convert_acquire..s#OOOuH3E::OOOr+cNg|]!}tjj|"Sr<)r MemorySlotrbrOirJs r)rz?QobjToInstructionConverter._convert_acquire..s,aaaX()@)CDDaaar+rfcNg|]!}tjj|"Sr<)r RegisterSlotrfrs r)rz?QobjToInstructionConverter._convert_acquire..s9HI%k&?&BCCr+Nrcc3<K|]}|dkVdSrNr<)rOrrcs r)rQz>QobjToInstructionConverter._convert_acquire..s2ZZ!~a N1$55ZZZZZZr+zbCan currently only support one discriminator per acquire. Defaulting to first discriminator entry.rr,rgc3<K|]}d|kVdSrr<)rOrrgs r)rQz>QobjToInstructionConverter._convert_acquire..s0EEAwqzWQZ'EEEEEEr+zTCan currently only support one kernel per acquire. Defaulting to first kernel entry.)rirprrrnr<)r`rarangerhasattrrcr%rTanywarningswarnrr,rergrzipr rN)rFrJr`raacquire_channels mem_slotsrrnrracquire_channelrirprcrgs ` @@r)rtz+QobjToInstructionConverter._convert_acquires'#OOOOOaaaaeTWX^T_T_N`N`aaa ; 0 0 2MRSVW]S^S^M_M_NN#Vc&kk1N+2+?O*P*P ZK & &VZ .$// .,-N ZZZZuSEXEX?Y?YZZZ Z Z  M0   'q)  c)bb~a/@/EbXYIZIabbM)0i)H)HR+%%d'4(( iG EEEEs7||1D1DEEE E E  M      GFFFGAJ4EFFF367GTb3c3c   /OXx&!!+       r+c#K||j}||j}t j||VdS)zReturn converted `SetPhase` instruction. Args: instruction: SetPhase qobj instruction Yields: Qiskit Pulse set phase instructions N)rryrrr rrFrJrlrs r) _convert_setpz(QobjToInstructionConverter._convert_setpsR"";>22&&{'899#E73333333r+c#K||j}||j}t j||VdS)zReturn converted `ShiftPhase` instruction. Args: instruction: ShiftPhase qobj instruction Yields: Qiskit Pulse shift phase schedule instructions N)rryrrr rrs r) _convert_fcz&QobjToInstructionConverter._convert_fcsR"";>22&&{'899%eW5555555r+c#K||j}||jdz}t j||VdS)afReturn converted `SetFrequencyInstruction` instruction. .. note:: We assume frequency value is expressed in string with "GHz". Operand value is thus scaled by a factor of 10^9. Args: instruction: SetFrequency qobj instruction Yields: Qiskit Pulse set frequency instructions rwN)rryrrzr rrFrJrlrzs r) _convert_setfz(QobjToInstructionConverter._convert_setfsW""";>22**;+@AAEI ' 7;;;;;;;r+c#K||j}||jdz}t j||VdS)ajReturn converted `ShiftFrequency` instruction. .. note:: We assume frequency value is expressed in string with "GHz". Operand value is thus scaled by a factor of 10^9. Args: instruction: ShiftFrequency qobj instruction Yields: Qiskit Pulse shift frequency schedule instructions rwN)rryrrzr rrs r)_convert_shiftfz*QobjToInstructionConverter._convert_shiftfsW""";>22**;+@AAEI ))W=======r+c#zK||j}|j}tj||VdS)zReturn converted `Delay` instruction. Args: instruction: Delay qobj instruction Yields: Qiskit Pulse delay instructions N)rryr`r r)rFrJrlr`s r)rz)QobjToInstructionConverter._convert_delaysD"";>22' 73333333r+c#K||j} |j}n#t$rt |jd}|jdt|}tj | d dd}|jd|}YnwxYwt|j}d|vrUt|dtr:t!j|d|d<t!j|d|d<t'|jd i|d |i}t+j||VdS) aReturn converted `Play` instruction with parametric pulse operand. .. note:: If parametric pulse label is not provided by the backend, this method naively generates a pulse name based on the pulse shape and bound parameters. This pulse name is formatted to, for example, `gaussian_a4e3`, here the last four digits are a part of the hash string generated based on the pulse shape and the parameters. Because we are using a truncated hash for readability, there may be a small risk of pulse name collision with other pulses. Basically the parametric pulse name is used just for visualization purpose and the pulse module should not have dependency on the parametric pulse names. Args: instruction: Play qobj instruction with parametric pulse Yields: Qiskit Pulse play schedule instructions c|dS)Nrr<)xs r)zFQobjToInstructionConverter._convert_parametric_pulse..Hs QRSTQUr+)key_zutf-8Nrrr,r<)rryrrsortedritemsrr;hashlibmd5encode hexdigestrr%rrrabsrr0r r) rFrJrl pulse_name sorted_paramsbase_strshort_pulse_idrers r)_convert_parametric_pulsez4QobjToInstructionConverter._convert_parametric_pulse,s."";>22 G$*JJ G G G";#9#?#?#A#A~~VVVM%1HHC 4F4FHHH$[)A)ABBLLNNrPQrRN'3FFnFFJJJ  G k,-- F??z&-AA? hve}55F7OF6%=11F5M%--k.EFFaaaaV`aaaw///////s&BCCc#LKtj|j|jVdS)zReturn converted `Snapshot` instruction. Args: instruction: Snapshot qobj instruction Yields: Qiskit Pulse snapshot instructions N)r rrr)rFrJs r)rz,QobjToInstructionConverter._convert_snapshotTs-#K$5{7GHHHHHHHr+c#ZK|j|jvr^tj|j|j|j}||j}t j||VdSt|ddx}rd|}n d|j}td|jd|d) zConvert generic pulse instruction. Args: instruction: Generic qobj instruction Yields: Qiskit Pulse generic instructions Raises: QiskitError: When instruction name not found. )rr,raNzqubits zchannel z Instruction z on zK is not found in Qiskit namespace. This instruction cannot be deserialized.) r,rr Waveformrryr rr.r)rFrJwaveformrlramsgs r)rz+QobjToInstructionConverter._convert_genericbs  t2 2 2'+K,<= %H&&{~66G#Hg66 6 6 6 6 6 h===v 2(((111P{/PPSPPP r+rM)&r1r2r3r4recompilerrrrrrHrrrXrr rrr;rr PulseChannelr staticmethodrfloatr rrtrrrrrr rrr<r+r)rrs4 RZ 344N;?&&%5 67&&& &$ $8 X    ')' ,* +''''<  DI     =3=8+@====2eE3J&7E%I\B\<]\$;); ,* +;;;;z4)4 ,* +4444"6)6 ,* +6666"<)< ,* +<<<<,>)> ,* +>>>>,4)4 ,* +4444"&0)&0 ,* +&0&0&0&0P I) I ,* + I I I I) ,* +r+r),r4rrrenumr functoolsrtypingrrrrnumpyrqiskit.circuitr r qiskit.pulser r r qiskit.pulse.configurationrrqiskit.pulse.exceptionsrqiskit.pulse.parserrqiskit.pulse.scheduler qiskit.qobjrrrqiskit.qobj.utilsr qiskit.utilsrqiskit.utils.deprecate_pulserrr>rr<r+r)r"sRQ ******222222222222999999998888888888<<<<<<<<//////111111******UUUUUUUUUU''''''''''''CCCCCC-1-1-1-1-1D-1-1-1`c0c0c0c0c0c0c0c0L FFFFFFFFFFr+