from .......Internal.Core import Core
from .......Internal.CommandsGroup import CommandsGroup
from .......Internal.RepeatedCapability import RepeatedCapability
from ....... import repcap
# noinspection PyPep8Naming,PyAttributeOutsideInit,SpellCheckingInspection
class GvectorCls:
"""
| Commands in total: 131
| Subgroups: 66
| Direct child commands: 1
Repeated Capability Setting:
.. code-block:: python
# Range: Nr1 .. Nr8 \n
driver.source.fsimulator.mimo.tap.gvector.repcap_gainVector_set(repcap.GainVector.Nr1)
"""
def __init__(self, core: Core, parent):
self._core = core
self._cmd_group = CommandsGroup("gvector", core, parent)
self._cmd_group.rep_cap = RepeatedCapability(self._cmd_group.group_name, 'repcap_gainVector_get', 'repcap_gainVector_set', repcap.GainVector.Nr1)
def repcap_gainVector_set(self, gainVector: repcap.GainVector) -> None:
"""
Repeated Capability default value numeric suffix.
This value is used, if you do not explicitely set it in the child set/get methods, or if you leave it to GainVector.Default.
Default value after init: GainVector.Nr1
"""
self._cmd_group.set_repcap_enum_value(gainVector)
def repcap_gainVector_get(self) -> repcap.GainVector:
"""
Returns the current default repeated capability for the child set/get methods.
"""
# noinspection PyTypeChecker
return self._cmd_group.get_repcap_enum_value()
@property
def aa(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_aa'):
from .Aa import AaCls
self._aa = AaCls(self._core, self._cmd_group)
return self._aa
@property
def ab(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ab'):
from .Ab import AbCls
self._ab = AbCls(self._core, self._cmd_group)
return self._ab
@property
def ac(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ac'):
from .Ac import AcCls
self._ac = AcCls(self._core, self._cmd_group)
return self._ac
@property
def ad(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ad'):
from .Ad import AdCls
self._ad = AdCls(self._core, self._cmd_group)
return self._ad
@property
def ae(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ae'):
from .Ae import AeCls
self._ae = AeCls(self._core, self._cmd_group)
return self._ae
@property
def af(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_af'):
from .Af import AfCls
self._af = AfCls(self._core, self._cmd_group)
return self._af
@property
def ag(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ag'):
from .Ag import AgCls
self._ag = AgCls(self._core, self._cmd_group)
return self._ag
@property
def ah(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ah'):
from .Ah import AhCls
self._ah = AhCls(self._core, self._cmd_group)
return self._ah
@property
def ba(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ba'):
from .Ba import BaCls
self._ba = BaCls(self._core, self._cmd_group)
return self._ba
@property
def bb(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_bb'):
from .Bb import BbCls
self._bb = BbCls(self._core, self._cmd_group)
return self._bb
@property
def bc(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_bc'):
from .Bc import BcCls
self._bc = BcCls(self._core, self._cmd_group)
return self._bc
@property
def bd(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_bd'):
from .Bd import BdCls
self._bd = BdCls(self._core, self._cmd_group)
return self._bd
@property
def be(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_be'):
from .Be import BeCls
self._be = BeCls(self._core, self._cmd_group)
return self._be
@property
def bf(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_bf'):
from .Bf import BfCls
self._bf = BfCls(self._core, self._cmd_group)
return self._bf
@property
def bg(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_bg'):
from .Bg import BgCls
self._bg = BgCls(self._core, self._cmd_group)
return self._bg
@property
def bh(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_bh'):
from .Bh import BhCls
self._bh = BhCls(self._core, self._cmd_group)
return self._bh
@property
def ca(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ca'):
from .Ca import CaCls
self._ca = CaCls(self._core, self._cmd_group)
return self._ca
@property
def cb(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_cb'):
from .Cb import CbCls
self._cb = CbCls(self._core, self._cmd_group)
return self._cb
@property
def cc(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_cc'):
from .Cc import CcCls
self._cc = CcCls(self._core, self._cmd_group)
return self._cc
@property
def cd(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_cd'):
from .Cd import CdCls
self._cd = CdCls(self._core, self._cmd_group)
return self._cd
@property
def ce(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ce'):
from .Ce import CeCls
self._ce = CeCls(self._core, self._cmd_group)
return self._ce
@property
def cf(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_cf'):
from .Cf import CfCls
self._cf = CfCls(self._core, self._cmd_group)
return self._cf
@property
def cg(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_cg'):
from .Cg import CgCls
self._cg = CgCls(self._core, self._cmd_group)
return self._cg
@property
def ch(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ch'):
from .Ch import ChCls
self._ch = ChCls(self._core, self._cmd_group)
return self._ch
@property
def da(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_da'):
from .Da import DaCls
self._da = DaCls(self._core, self._cmd_group)
return self._da
@property
def db(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_db'):
from .Db import DbCls
self._db = DbCls(self._core, self._cmd_group)
return self._db
@property
def dc(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_dc'):
from .Dc import DcCls
self._dc = DcCls(self._core, self._cmd_group)
return self._dc
@property
def dd(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_dd'):
from .Dd import DdCls
self._dd = DdCls(self._core, self._cmd_group)
return self._dd
@property
def de(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_de'):
from .De import DeCls
self._de = DeCls(self._core, self._cmd_group)
return self._de
@property
def df(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_df'):
from .Df import DfCls
self._df = DfCls(self._core, self._cmd_group)
return self._df
@property
def dg(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_dg'):
from .Dg import DgCls
self._dg = DgCls(self._core, self._cmd_group)
return self._dg
@property
def dh(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_dh'):
from .Dh import DhCls
self._dh = DhCls(self._core, self._cmd_group)
return self._dh
@property
def ea(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ea'):
from .Ea import EaCls
self._ea = EaCls(self._core, self._cmd_group)
return self._ea
@property
def eb(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_eb'):
from .Eb import EbCls
self._eb = EbCls(self._core, self._cmd_group)
return self._eb
@property
def ec(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ec'):
from .Ec import EcCls
self._ec = EcCls(self._core, self._cmd_group)
return self._ec
@property
def ed(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ed'):
from .Ed import EdCls
self._ed = EdCls(self._core, self._cmd_group)
return self._ed
@property
def ee(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ee'):
from .Ee import EeCls
self._ee = EeCls(self._core, self._cmd_group)
return self._ee
@property
def ef(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ef'):
from .Ef import EfCls
self._ef = EfCls(self._core, self._cmd_group)
return self._ef
@property
def eg(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_eg'):
from .Eg import EgCls
self._eg = EgCls(self._core, self._cmd_group)
return self._eg
@property
def eh(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_eh'):
from .Eh import EhCls
self._eh = EhCls(self._core, self._cmd_group)
return self._eh
@property
def fa(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_fa'):
from .Fa import FaCls
self._fa = FaCls(self._core, self._cmd_group)
return self._fa
@property
def fb(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_fb'):
from .Fb import FbCls
self._fb = FbCls(self._core, self._cmd_group)
return self._fb
@property
def fc(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_fc'):
from .Fc import FcCls
self._fc = FcCls(self._core, self._cmd_group)
return self._fc
@property
def fd(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_fd'):
from .Fd import FdCls
self._fd = FdCls(self._core, self._cmd_group)
return self._fd
@property
def fe(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_fe'):
from .Fe import FeCls
self._fe = FeCls(self._core, self._cmd_group)
return self._fe
@property
def ff(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ff'):
from .Ff import FfCls
self._ff = FfCls(self._core, self._cmd_group)
return self._ff
@property
def fg(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_fg'):
from .Fg import FgCls
self._fg = FgCls(self._core, self._cmd_group)
return self._fg
@property
def fh(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_fh'):
from .Fh import FhCls
self._fh = FhCls(self._core, self._cmd_group)
return self._fh
@property
def ga(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ga'):
from .Ga import GaCls
self._ga = GaCls(self._core, self._cmd_group)
return self._ga
@property
def gain(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_gain'):
from .Gain import GainCls
self._gain = GainCls(self._core, self._cmd_group)
return self._gain
@property
def gb(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_gb'):
from .Gb import GbCls
self._gb = GbCls(self._core, self._cmd_group)
return self._gb
@property
def gc(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_gc'):
from .Gc import GcCls
self._gc = GcCls(self._core, self._cmd_group)
return self._gc
@property
def gd(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_gd'):
from .Gd import GdCls
self._gd = GdCls(self._core, self._cmd_group)
return self._gd
@property
def ge(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ge'):
from .Ge import GeCls
self._ge = GeCls(self._core, self._cmd_group)
return self._ge
@property
def gf(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_gf'):
from .Gf import GfCls
self._gf = GfCls(self._core, self._cmd_group)
return self._gf
@property
def gg(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_gg'):
from .Gg import GgCls
self._gg = GgCls(self._core, self._cmd_group)
return self._gg
@property
def gh(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_gh'):
from .Gh import GhCls
self._gh = GhCls(self._core, self._cmd_group)
return self._gh
@property
def ha(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_ha'):
from .Ha import HaCls
self._ha = HaCls(self._core, self._cmd_group)
return self._ha
@property
def hb(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_hb'):
from .Hb import HbCls
self._hb = HbCls(self._core, self._cmd_group)
return self._hb
@property
def hc(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_hc'):
from .Hc import HcCls
self._hc = HcCls(self._core, self._cmd_group)
return self._hc
@property
def hd(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_hd'):
from .Hd import HdCls
self._hd = HdCls(self._core, self._cmd_group)
return self._hd
@property
def he(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_he'):
from .He import HeCls
self._he = HeCls(self._core, self._cmd_group)
return self._he
@property
def hf(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_hf'):
from .Hf import HfCls
self._hf = HfCls(self._core, self._cmd_group)
return self._hf
@property
def hg(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_hg'):
from .Hg import HgCls
self._hg = HgCls(self._core, self._cmd_group)
return self._hg
@property
def hh(self):
"""
| Commands in total: 2
| Subgroups: 2
| Direct child commands: 0
"""
if not hasattr(self, '_hh'):
from .Hh import HhCls
self._hh = HhCls(self._core, self._cmd_group)
return self._hh
@property
def phase(self):
"""
| Commands in total: 1
| Subgroups: 0
| Direct child commands: 1
"""
if not hasattr(self, '_phase'):
from .Phase import PhaseCls
self._phase = PhaseCls(self._core, self._cmd_group)
return self._phase
[docs]
def preset(self, mimoTap=repcap.MimoTap.Default) -> None:
"""
``[SOURce<HW>]:FSIMulator:MIMO:TAP<CH>:GVECtor:PRESet`` \n
Snippet: ``driver.source.fsimulator.mimo.tap.gvector.preset(mimoTap = repcap.MimoTap.Default)`` \n
Presets the vector matrix to a unitary matrix.
:param mimoTap: optional repeated capability selector. Default value: Nr1 (settable in the interface 'Tap')
"""
mimoTap_cmd_val = self._cmd_group.get_repcap_cmd_value(mimoTap, repcap.MimoTap)
self._core.io.write(f'SOURce<HwInstance>:FSIMulator:MIMO:TAP{mimoTap_cmd_val}:GVECtor:PRESet')
[docs]
def preset_with_opc(self, mimoTap=repcap.MimoTap.Default, opc_timeout_ms: int = -1) -> None:
mimoTap_cmd_val = self._cmd_group.get_repcap_cmd_value(mimoTap, repcap.MimoTap)
"""
``[SOURce<HW>]:FSIMulator:MIMO:TAP<CH>:GVECtor:PRESet`` \n
Snippet: ``driver.source.fsimulator.mimo.tap.gvector.preset_with_opc(mimoTap = repcap.MimoTap.Default)`` \n
Presets the vector matrix to a unitary matrix.
Same as preset, but waits for the operation to complete before continuing further. Use the RsSmw.utilities.opc_timeout_set() to set the timeout value.
:param mimoTap: optional repeated capability selector. Default value: Nr1 (settable in the interface 'Tap')
:param opc_timeout_ms: Maximum time to wait in milliseconds, valid only for this call.
"""
self._core.io.write_with_opc(f'SOURce<HwInstance>:FSIMulator:MIMO:TAP{mimoTap_cmd_val}:GVECtor:PRESet', opc_timeout_ms)
def clone(self) -> 'GvectorCls':
"""
Clones the group by creating new object from it and its whole existing subgroups.
Also copies all the existing default Repeated Capabilities setting,
which you can change independently without affecting the original group.
"""
new_group = GvectorCls(self._core, self._cmd_group.parent)
self._cmd_group.synchronize_repcaps(new_group)
return new_group