def send(self, name, value=None, **kwargs):
"""performs send of parameter name i.e. executing associated set_cmd. If value is specified, parameter is set to value
kwargs allows additional parameters required by set_cmd to be fed in."""
set_cmd = get_tag(self, name, 'set_cmd')
if self.status == "Active":
if set_cmd != None and self.status == 'Active':
if not hasattr(set_cmd, "pname"):
set_cmd = log_func(set_cmd, name)
set_tag(self, name, set_cmd=set_cmd)
Instrument.busy = True
temp = get_tag(self, name, 'send_now', self.send_now)
set_tag(self, name, send_now=False)
if value != None:
setattr(self, name, value)
self.send_log(name)
set_cmd(self, **kwargs)
set_tag(self, name, send_now=temp)
Instrument.busy = False
else:
log_warning(
"WARNING: {instr} {name} set_cmd doesn't exist".format(
instr=self.name, name=name))
else:
log_warning("WARNING: Instrument {instr} not active".format(
instr=self.name))
def latex_table2(self, param_list=None):
if param_list is None:
param_list = self.main_params
lt = [
[self.name, r"Value", r"Expression", r"Comment"],
]
for param in param_list:
unit = get_tag(self, param, "unit")
#print param, type(getattr(self, param)) in (int, float, float64)
if type(getattr(self, param)) in (int, float, float64):
format_str = getattr(unit, "format_str", r"{0:.3g}")
else:
format_str = getattr(unit, "format_str", "{0}")
print param, format_str
if unit is not None:
unit.show_unit()
value = getattr(self, param) / unit
else:
value = getattr(self, param)
tex_str = get_tag(self, param, "tex_str")
if tex_str is None:
tex_str = param.replace("_", " ")
label = get_tag(self, param, "label")
if label is not None:
tex_str = label + ", " + tex_str
lt.append([
tex_str,
format_str.format(value),
get_tag(self, param, "expression", r"{}"),
get_tag(self, param, "desc", r"{}")
])
return lt
def command_response(self, command, resp_delay, response):
if get_tag(self, "command", "do", False):
self.send(command=command)
if get_tag(self, "resp_delay", "do", False):
self.wait_loop(self.resp_delay)
if get_tag(self, "response", "do", False):
self.receive("response")
def latex_table2(self, param_list=None):
if param_list is None:
param_list=self.main_params
lt = [[self.name, r"Value", r"Expression", r"Comment"],]
for param in param_list:
unit=get_tag(self, param, "unit")
#print param, type(getattr(self, param)) in (int, float, float64)
if type(getattr(self, param)) in (int, float, float64):
format_str=getattr(unit, "format_str", r"{0:.3g}")
else:
format_str=getattr(unit, "format_str", "{0}")
print param, format_str
if unit is not None:
unit.show_unit()
value=getattr(self, param)/unit
else:
value=getattr(self, param)
tex_str=get_tag(self, param, "tex_str")
if tex_str is None:
tex_str=param.replace("_", " ")
label=get_tag(self, param, "label")
if label is not None:
tex_str=label+", "+tex_str
lt.append([tex_str, format_str.format(value),
get_tag(self, param, "expression", r"{}"), get_tag(self, param, "desc", r"{}")])
return lt
def start_GPIB(
instr,
address, #delay, timeout,
reset,
selftest, #send_end,
identify,
clear,
resource_manager,
session,
access_key):
if address == "":
raise InstrumentError("{0}: GPIB instruments need addresses.".format(
instr.name))
instr.address = address
instr.resource_manager = visa.ResourceManager()
instr.session = instr.resource_manager.open_resource(
address) #visa.instrument(address)
#self.session = visa.instrument(self.address, lock = lock, timeout = timeout, send_end=send_end, values_format = visa.single) #values_format=visa.single | visa.big_endian)
if get_tag(instr, "access_key", "do", False):
instr.access_key = GPIB_lock(instr)
instr.lock = True
if get_tag(instr, "clear", "do", False):
instr.clear()
if get_tag(instr, "reset", "do", False):
instr.reset()
if get_tag(instr, "selftest", "do", False):
instr.selftest()
if get_tag(instr, "identify", "do", False):
instr.receive('identify')
log_info("GPIB instrument {name} initialized at address {address}".format(
name=instr.name, address=address))
def command_response(self):
if get_tag(self, "command", "do", False):
self.send("command")
if get_tag(self, "resp_delay", "do", False):
sleep(self.resp_delay)
if get_tag(self, "response", "do", False):
self.receive("response")
def receive(self, name, **kwargs):
"""performs receive of parameter name i.e. executing associated get_cmd with value checking"""
get_cmd = get_tag(self, name, 'get_cmd')
if self.status == "Active":
if get_cmd != None:
if not hasattr(get_cmd, "pname"):
get_cmd = log_func(get_cmd, name)
set_tag(self, name, get_cmd=get_cmd)
self.receive_log(name)
Instrument.busy = True
value = get_cmd(self, **kwargs)
log_debug(value)
Instrument.busy = False
temp = get_tag(self, name, 'send_now', self.send_now)
set_tag(self, name, send_now=False)
value = get_value_check(self, name, value)
setattr(self, name, value)
set_tag(self, name, send_now=temp)
else:
log_warning(
"WARNING: {instr} {name} get_cmd doesn't exist".format(
instr=self.name, name=name))
else:
log_warning("WARNING: Instrument {instr} not active".format(
instr=self.name))
def command_response(self, command, resp_delay, response):
if get_tag(self, "command", "do", False):
self.send(command=command)
if get_tag(self, "resp_delay", "do", False):
self.wait_loop(self.resp_delay)
if get_tag(self, "response", "do", False):
self.receive("response")
def __setattr__(self, name, value):
"""extends __setattr__ to add automatic sending if tag send_now is true.
This is preferable to using observing since it is called everytime the parameter value is set,
not just when it changes."""
super(Instrument, self).__setattr__( name, value)
if name in self.all_params:
if get_tag(self, name, 'send_now', self.send_now):
if get_tag(self, name, 'set_cmd')!=None:
self.send(**{name:value})
def latex_value(self, param):
unit=get_tag(self, param, "unit")
if unit is None:
if type(getattr(self, param)) in (int, float, float64):
value=(r"{0:."+str(get_tag(self, param, "precision", 4))+"g}").format(getattr(self, param))
else:
value = str(getattr(self, param))
else:
value=unit.show_unit(getattr(self, param)/unit, get_tag(self, param, "precision", 4))
return value
def extra_setup(self, param, typer):
super(Instrument, self).extra_setup(param, typer)
aka = get_tag(self, param, "aka")
if aka!=None:
do=get_tag(self, param, "do", False)
set_tag(self, param, set_cmd=COM_write_it(aka, param), do=do)
GPIB_string=get_tag(self, param, 'GPIB_asks')
if GPIB_string!=None:
do=get_tag(self, param, "do", False)
set_tag(self, param, get_cmd=COM_ask_it(aka, param), do=do)
def extra_setup(self, param, typer):
super(GPIB_Instrument, self).extra_setup(param, typer)
GPIB_string=get_tag(self, param, 'GPIB_writes')
if GPIB_string!=None:
do=get_tag(self, param, "do", False)
set_tag(self, param, set_cmd=GPIB_write_it(GPIB_string, param), do=do)
GPIB_string=get_tag(self, param, 'GPIB_asks')
if GPIB_string!=None:
do=get_tag(self, param, "do", False)
set_tag(self, param, get_cmd=GPIB_ask_it(GPIB_string, param), do=do)
def extra_setup(self, param, typer):
super(Instrument, self).extra_setup(param, typer)
aka = get_tag(self, param, "aka")
if aka != None:
do = get_tag(self, param, "do", False)
set_tag(self, param, set_cmd=COM_write_it(aka, param), do=do)
GPIB_string = get_tag(self, param, 'GPIB_asks')
if GPIB_string != None:
do = get_tag(self, param, "do", False)
set_tag(self, param, get_cmd=COM_ask_it(aka, param), do=do)
def extra_setup(self, param, typer):
"""extends extra_setup to set response get_cmd to self.reader
and autoset set_cmd and get_cmd for params with get_str and set_str"""
set_tag(self, "response", get_cmd=self.reader)
write_string=get_tag(self, param, 'set_str')
if write_string!=None:
do=get_tag(self, param, "do", False)
set_tag(self, param, set_cmd=new_write_it(param, write_string, self.log_prefix), do=do)
ask_string=get_tag(self, param, 'get_str')
if ask_string!=None:
do=get_tag(self, param, "do", False)
set_tag(self, param, get_cmd=new_ask_it(param, ask_string, self.log_prefix), do=do)
super(String_Instrument, self).extra_setup(param, typer)
def start_GPIB(instr, address, delay, timeout, reset, selftest, lock, send_end, identify, clear):
if address=="":
raise InstrumentError("{0}: GPIB instruments need addresses.".format(instr.name))
instr.address=address
instr.session=visa.instrument(address)
#self.session = visa.instrument(self.address, lock = lock, timeout = timeout, send_end=send_end, values_format = visa.single) #values_format=visa.single | visa.big_endian)
if get_tag(instr, "clear", "do", False):
instr.clear()
if get_tag(instr, "reset", "do", False):
instr.reset()
if get_tag(instr, "selftest", "do", False):
instr.selftest()
if get_tag(instr, "identify", "do", False):
instr.receive('identify')
log_info("GPIB instrument {name} initialized at address {address}".format(name=instr.name, address=address))
def booter(self, address):
self.VNA=CreateObject("AgilentNA.AgilentNA")
init_list=['Simulate={0}'.format(self.simulate),
#'QueryInstrStatus=true'
]
init_str=','.join(init_list)
print init_str
log_debug(self.VNA.Initialize(self.address, False, False, init_str))
self.ch1=self.VNA.Channels["Channel1"]
if not self.simulate:
print self.VNA.System2.IO.IO.LockRsrc()
if get_tag(self, 'abort', 'do', False):
self.VNA_abort()
#self.VNA_write("CALC:PAR:DEL:ALL")
self.error_query()
#log_debug(self.VNA.System2.WaitForOperationComplete(self.timeout))
#self.error_query()
self.measS11=self.ch1.Measurements["Measurement1"]
self.measS21=self.ch1.Measurements["Measurement2"]
self.measS12=self.ch1.Measurements["Measurement3"]
self.measS22=self.ch1.Measurements["Measurement4"]
if self.simulate:
self.stop_freq=4.0e9
#sleep(1)
#self.measS11.Create(1, 1)
#self.error_query()
#sleep(1)
#self.measS11.Delete()
#self.synchronize()
self.error_query()
def setup_units(self, param, typer):
"""autosets units using unit_dict"""
unit = get_tag(self, param, "unit")
if unit is not None:
unit_dict = getattr(self, "unit_dict", UNIT_DICT)
if unit in unit_dict:
set_tag(self, param, unit=unit_dict[unit])
def setup_units(self, param, typer):
"""autosets units using unit_dict"""
unit=get_tag(self, param, "unit")
if unit is not None:
unit_dict=getattr(self, "unit_dict", UNIT_DICT)
if unit in unit_dict:
set_tag(self, param, unit=unit_dict[unit])
def booter(self, address, delay, timeout, reset, selftest, lock, send_end,
identify, clear, header):
start_GPIB(self, address, delay, timeout, reset, selftest, lock,
send_end, identify, clear)
sleep(0.05) #yoko crashes if this pause isn't after the clear
if get_tag(self, "header", "do", False):
self.header.send()
def booter(self, address):
self.VNA = CreateObject("AgilentNA.AgilentNA")
init_list = [
'Simulate={0}'.format(self.simulate),
#'QueryInstrStatus=true'
]
init_str = ','.join(init_list)
print init_str
log_debug(self.VNA.Initialize(self.address, False, False, init_str))
self.ch1 = self.VNA.Channels["Channel1"]
if not self.simulate:
print self.VNA.System2.IO.IO.LockRsrc()
if get_tag(self, 'abort', 'do', False):
self.VNA_abort()
#self.VNA_write("CALC:PAR:DEL:ALL")
self.error_query()
#log_debug(self.VNA.System2.WaitForOperationComplete(self.timeout))
#self.error_query()
self.measS11 = self.ch1.Measurements["Measurement1"]
self.measS21 = self.ch1.Measurements["Measurement2"]
self.measS12 = self.ch1.Measurements["Measurement3"]
self.measS22 = self.ch1.Measurements["Measurement4"]
if self.simulate:
self.stop_freq = 4.0e9
#sleep(1)
#self.measS11.Create(1, 1)
#self.error_query()
#sleep(1)
#self.measS11.Delete()
#self.synchronize()
self.error_query()
def do_receive(self, name, **kwargs):
"""performs receive of parameter name i.e. executing associated get_cmd with value checking"""
get_cmd=get_tag(self, name, 'get_cmd')
if self.status=="Active":
if get_cmd!=None:
if not hasattr(get_cmd, "pname"):
get_cmd=log_func(get_cmd, name)
set_tag(self, name, get_cmd=get_cmd)
self.receive_log(name)
value=get_cmd(self, **kwargs)
if isinstance(value, dict):
self.nosend_safeset(**value)
return value[name]
else:
self.nosend_safeset(**{name:value})
return value
# #safe_log(value)
# with self.nosend_context(name):
# value=type(getattr(self, name))(value)
# value=get_value_check(self, name, value)
# safe_setattr(self, name, value)
#return value
else:
print "WARNING: {instr} {name} get_cmd doesn't exist".format(instr=self.name, name=name)
else:
print "WARNING: Instrument {instr} not active".format(instr=self.name)
def latex_table_entry(self,
param=None,
value=None,
expression=None,
comment=None):
if param is None:
return [self.name, r"Value", r"Expression", r"Comment"]
tex_str = get_tag(self, param, "tex_str")
if tex_str is None:
tex_str = param.replace("_", " ")
label = get_tag(self, param, "label")
if label is not None:
tex_str = label + ", " + tex_str
unit = get_tag(self, param, "unit")
if value is None:
if unit is None:
if type(getattr(self, param)) in (int, float, float64):
value = (r"{0:." +
str(get_tag(self, param, "precision", 4)) +
"g}").format(getattr(self, param))
else:
value = str(getattr(self, param))
else:
value = unit.show_unit(
getattr(self, param) / unit,
get_tag(self, param, "precision", 4))
if expression is None:
expression = get_tag(self, param, "expression", r"{}")
if comment is None:
comment = get_tag(self, param, "desc", r"{}")
return [tex_str, value, expression, comment]
def synchronize(self):
tlist = [
param for param in self.main_params
if get_tag(self, param, 'get_cmd') is not None
]
for cmd in set(tlist):
self.receive(param)
self.wait_loop(self.resp_delay)
def latex_table_entry(self, param=None, value=None, expression=None, comment=None, design=None, label=None):
if param is None:
return [self.name.replace("_", " "), r"Label", r"Value", r"Design", r"Comment"]
#tex_str=get_tag(self, param, "tex_str")
#if tex_str is None:
# tex_str=param.replace("_", " ")
if label is None:
label=get_tag(self, param, "label", r"{}")
if value is None:
value=latex_value(self, param)
if expression is None:
expression=get_tag(self, param, "expression", param.replace("_", " "))
if comment is None:
comment=get_tag(self, param, "desc", r"{}")
if design is None:
design=get_tag(self, param, "design", r"{}")
return [expression, label, value, design, comment]
def extra_setup(self, param, typer):
"""extends extra_setup to set response get_cmd to self.reader
and autoset set_cmd and get_cmd for params with get_str and set_str"""
set_tag(self, "response", get_cmd=self.reader)
write_string = get_tag(self, param, 'set_str')
if write_string != None:
do = get_tag(self, param, "do", False)
set_tag(self,
param,
set_cmd=new_write_it(param, write_string, self.log_prefix),
do=do)
ask_string = get_tag(self, param, 'get_str')
if ask_string != None:
do = get_tag(self, param, "do", False)
set_tag(self,
param,
get_cmd=new_ask_it(param, ask_string, self.log_prefix),
do=do)
super(String_Instrument, self).extra_setup(param, typer)
def process_kwargs(self, kwargs):
"""Goes through all_params and sets the attribute if it is included in kwargs, also popping it out of kwargs.
if the param is tagged with "former", the kwarg is added back using the value of the param. Returns the processed kwargs"""
for arg in get_all_params(self): #get_all_tags(self, "former"):
if arg in kwargs:
setattr(self, arg, kwargs[arg])
val=kwargs.pop(arg, None)
key=get_tag(self, arg, "former", False)
if key is not False:
if val is None:
val=getattr(self, arg)
kwargs[key]=val
return kwargs
def changer(self, change):
if change["type"]=="update":
param=change["name"]
refresh_legend=get_tag(self, param, "refresh_legend", False)
if refresh_legend:
temp=self.plotter.show_legend
self.plotter.show_legend=False
getattr(self.plotter.clts[self.name], "set_"+param)(getattr(self, param))
if refresh_legend:
self.plotter.show_legend=True
self.plotter.show_legend=temp
if self.plotter.auto_draw:
self.plotter.draw()
def process_kwargs(self, kwargs):
"""Goes through all_params and sets the attribute if it is included in kwargs, also popping it out of kwargs.
if the param is tagged with "former", the kwarg is added back using the value of the param. Returns the processed kwargs"""
for arg in get_all_params(self): #get_all_tags(self, "former"):
if arg in kwargs:
setattr(self, arg, kwargs[arg])
val = kwargs.pop(arg, None)
key = get_tag(self, arg, "former", False)
if key is not False:
if val is None:
val = getattr(self, arg)
kwargs[key] = val
return kwargs
def send(self, name, value=None, **kwargs):
"""performs send of parameter name i.e. executing associated set_cmd. If value is specified, parameter is set to value
kwargs allows additional parameters required by set_cmd to be fed in."""
set_cmd=get_tag(self, name, 'set_cmd')
if self.status=="Active":
if set_cmd!=None and self.status=='Active':
if not hasattr(set_cmd, "pname"):
set_cmd=log_func(set_cmd, name)
set_tag(self, name, set_cmd=set_cmd)
Instrument.busy=True
temp=get_tag(self, name, 'send_now', self.send_now)
set_tag(self, name, send_now=False)
if value!=None:
setattr(self, name, value)
self.send_log(name)
set_cmd(self, **kwargs)
set_tag(self, name, send_now=temp)
Instrument.busy=False
else:
log_warning("WARNING: {instr} {name} set_cmd doesn't exist".format(instr=self.name, name=name))
else:
log_warning("WARNING: Instrument {instr} not active".format(instr=self.name))
def changer(self, change):
if change["type"] == "update":
param = change["name"]
refresh_legend = get_tag(self, param, "refresh_legend", False)
if refresh_legend:
temp = self.plotter.show_legend
self.plotter.show_legend = False
getattr(self.plotter.clts[self.name],
"set_" + param)(getattr(self, param))
if refresh_legend:
self.plotter.show_legend = True
self.plotter.show_legend = temp
if self.plotter.auto_draw:
self.plotter.draw()
def receive(self, name, **kwargs):
"""performs receive of parameter name i.e. executing associated get_cmd with value checking"""
get_cmd=get_tag(self, name, 'get_cmd')
if self.status=="Active":
if get_cmd!=None:
if not hasattr(get_cmd, "pname"):
get_cmd=log_func(get_cmd, name)
set_tag(self, name, get_cmd=get_cmd)
self.receive_log(name)
Instrument.busy=True
value=get_cmd(self, **kwargs)
log_debug(value)
Instrument.busy=False
temp=get_tag(self, name, 'send_now', self.send_now)
set_tag(self, name, send_now=False)
value=get_value_check(self, name, value)
setattr(self, name, value)
set_tag(self, name, send_now=temp)
else:
log_warning("WARNING: {instr} {name} get_cmd doesn't exist".format(instr=self.name, name=name))
else:
log_warning("WARNING: Instrument {instr} not active".format(instr=self.name))
def start_GPIB(instr, address, #delay, timeout,
reset, selftest, #send_end,
identify, clear,
resource_manager, session, access_key):
if address=="":
raise InstrumentError("{0}: GPIB instruments need addresses.".format(instr.name))
instr.address=address
instr.resource_manager=visa.ResourceManager()
instr.session=instr.resource_manager.open_resource(address) #visa.instrument(address)
#self.session = visa.instrument(self.address, lock = lock, timeout = timeout, send_end=send_end, values_format = visa.single) #values_format=visa.single | visa.big_endian)
if get_tag(instr, "access_key", "do", False):
instr.access_key=GPIB_lock(instr)
instr.lock=True
if get_tag(instr, "clear", "do", False):
instr.clear()
if get_tag(instr, "reset", "do", False):
instr.reset()
if get_tag(instr, "selftest", "do", False):
instr.selftest()
if get_tag(instr, "identify", "do", False):
instr.receive('identify')
log_info("GPIB instrument {name} initialized at address {address}".format(name=instr.name, address=address))
def do_send(self, name, value=None, **kwargs):
"""performs send of parameter name i.e. executing associated set_cmd. If value is specified, parameter is set to value
kwargs allows additional parameters required by set_cmd to be fed in."""
if self.status=="Active":
set_cmd=get_tag(self, name, 'set_cmd')
if set_cmd!=None:
if not hasattr(set_cmd, "pname"):
set_cmd=log_func(set_cmd, name)
set_tag(self, name, set_cmd=set_cmd)
with self.nosend_context(name):
if value is not None:
safe_setattr(self, name, value)
self.send_log(name)
value=set_cmd(self, **kwargs)
else:
print "WARNING: {instr} {name} set_cmd doesn't exist".format(instr=self.name, name=name)
else:
print "WARNING: Instrument {instr} not active".format(instr=self.name)
def new_func(self, *args, **kwargs):
"""logs the call of an instance method and autoinserts kwargs"""
if get_tag(self, name, "log", False):
log_debug("RAN: {}".format(name), n=1)
if len(args)==0:
members=self.members()
for param in get_run_params(new_func):
if param in members:
if param in kwargs:
try:
setattr(self, param, kwargs[param])
except TypeError:
pass
else:
if param in get_property_names(self):
self.get_member(param).reset(self)
value=getattr(self, param)
#value=set_value_map(obj, param, value)
kwargs[param]=value
#if hasattr(obj, "chief"): #not working. how to get return value?
# objargs=(obj,)+args
# return_value=do_it_if_needed(obj.chief, self.func, *objargs, **kwargs)
#else:
return func(self, *args, **kwargs)
def new_func(self, *args, **kwargs):
"""logs the call of an instance method and autoinserts kwargs"""
if get_tag(self, name, "log", False):
log_debug("RAN: {}".format(name), n=1)
if len(args) == 0:
members = self.members()
for param in get_run_params(new_func):
if param in members:
if param in kwargs:
try:
setattr(self, param, kwargs[param])
except TypeError:
pass
else:
if param in get_property_names(self):
self.get_member(param).reset(self)
value = getattr(self, param)
#value=set_value_map(obj, param, value)
kwargs[param] = value
#if hasattr(obj, "chief"): #not working. how to get return value?
# objargs=(obj,)+args
# return_value=do_it_if_needed(obj.chief, self.func, *objargs, **kwargs)
#else:
return func(self, *args, **kwargs)
def latex_table_entry(self, param=None, value=None, expression=None, comment=None):
if param is None:
return [self.name, r"Value", r"Expression", r"Comment"]
tex_str=get_tag(self, param, "tex_str")
if tex_str is None:
tex_str=param.replace("_", " ")
label=get_tag(self, param, "label")
if label is not None:
tex_str=label+", "+tex_str
unit=get_tag(self, param, "unit")
if value is None:
if unit is None:
if type(getattr(self, param)) in (int, float, float64):
value=(r"{0:."+str(get_tag(self, param, "precision", 4))+"g}").format(getattr(self, param))
else:
value = str(getattr(self, param))
else:
value=unit.show_unit(getattr(self, param)/unit, get_tag(self, param, "precision", 4))
if expression is None:
expression=get_tag(self, param, "expression", r"{}")
if comment is None:
comment=get_tag(self, param, "desc", r"{}")
return [tex_str, value, expression, comment]
@tag_Callable(label="Ramp")
def ramp(self, ramp_end, ramp_steps, sleep_time):
self.receive("voltage")
for v in linspace(self.voltage, ramp_end, ramp_steps):
self.send("voltage", v) #float("{0:.4f}".format(v))
sleep(sleep_time)
ramp_end=Float(0).tag(sub=True, unit2="V", label="Ramp End")
sleep_time=Float(0.5).tag(sub=True, unit2="s", label="Step Time")
ramp_steps=Int(3).tag(sub=True, label="Ramp Steps")
if __name__=="__main__":
a=Yoko(address="GPIB0::10::INSTR")
print get_tag(a, "voltage", "set_cmd")
from taref.core.shower import shower
shower(a)
#a.ramp_steps=3
#a.ramp()
#a.voltage.send(0.0)
#a.send("voltage=0.2")
#time.sleep(0.05)
#Simple ramp example
#a.receive("voltage")
#time.sleep(0.05)
#for v in np.linspace(a.voltage.value, 1, 10):
# a.voltage.send(v) #float("{0:.4f}".format(v))
# time.sleep(0.5)
#a.ramp=True
print 'set_tag(t, "a", z="p")'
set_tag(t, "a", z="p")
print 'print t.get_member("a").metadata'
print t.get_member("a").metadata
print 'print t.get_member("b").metadata'
print t.get_member("b").metadata
print
print 'set_all_tags(t, z=True)'
set_all_tags(t, z=True)
print 'print t.get_member("a").metadata'
print t.get_member("a").metadata
print 'print t.get_member("b").metadata'
print t.get_member("b").metadata
print
print 'get_tag(t, "a", "tg", "five")'
print get_tag(t, "a", "tg", "five")
print 'get_tag(t, "b", "tg", "five")'
print get_tag(t, "b", "tg", "five")
print 'get_tag(t, "a", "tg")'
print get_tag(t, "a", "tg")
print 'get_tag(t, "b", "tg")'
print get_tag(t, "b", "tg")
print
log_info("test code:")
class Test(Atom):
a=Int().tag(tg=4)
b=Float()
c=Unicode("blah").tag(tg=4)
d=Bool().tag(tg=5)
t=Test()
print """class Test(Atom):
qdt.material = 'LiNbYZ'
qdt.ft = "double"
qdt.Np = 5
qdt.Rn = 5200.0 #(5600.0+5100.0)/2.0
qdt.W = 7.0e-6
qdt.a = 96.0e-9
qdt.eta = 0.5
qdt.flux_factor = 0.302 #0.2945,
qdt.voltage = 1.21
qdt.offset = 0.02
qdt.Ec = 0.8e9 * h
idt = IDT(material='LiNbYZ', ft="double", Np=81, W=7.0e-6, eta=0.5, a=96.0e-9)
if __name__ == "__main__":
print get_tag(qdt, "a", "unit")
print qdt.latex_table()
from taref.plotter.fig_format import Plotter
from taref.physics.fundamentals import sinc, sinc_sq
b = Plotter()
from numpy import linspace, pi, absolute, sqrt, sin
freq = linspace(1e9, 10e9, 1000)
#qdt.ft="single"
#qdt.get_member("mult").reset(qdt)
#qdt.get_member("lbda0").reset(qdt)
print qdt.f0, qdt.G_f0
if 0:
#G_f=(1.0/sqrt(2.0))*0.5*qdt.Np*qdt.K2*qdt.f0*absolute(sinc(qdt.Np*pi*(freq-qdt.f0)/qdt.f0))
#b.line_plot("sinc", freq, G_f, label="sinc/sqrt(2)")
#G_f=0.5*qdt.Np*qdt.K2*qdt.f0*absolute(sinc(qdt.Np*pi*(freq-qdt.f0)/qdt.f0))
@tag_Callable(label="Ramp")
def ramp(self, ramp_end, ramp_steps, sleep_time):
self.receive("voltage")
for v in linspace(self.voltage, ramp_end, ramp_steps):
self.send("voltage", v) #float("{0:.4f}".format(v))
sleep(sleep_time)
ramp_end = Float(0).tag(sub=True, unit2="V", label="Ramp End")
sleep_time = Float(0.5).tag(sub=True, unit2="s", label="Step Time")
ramp_steps = Int(3).tag(sub=True, label="Ramp Steps")
if __name__ == "__main__":
a = Yoko(address="GPIB0::10::INSTR")
print get_tag(a, "voltage", "set_cmd")
from taref.core.shower import shower
shower(a)
#a.ramp_steps=3
#a.ramp()
#a.voltage.send(0.0)
#a.send("voltage=0.2")
#time.sleep(0.05)
#Simple ramp example
#a.receive("voltage")
#time.sleep(0.05)
#for v in np.linspace(a.voltage.value, 1, 10):
# a.voltage.send(v) #float("{0:.4f}".format(v))
# time.sleep(0.5)
#a.ramp=True
#const.base_flux_offset = (0.343-0.2121)/2;
#qdt.flux_factor=0.3
#qdt.voltage=1.21
#qdt.offset= 0.1195;
idt=IDT()
idt.material='GaAs'
idt.ft="single"
idt.Np=125
idt.W=25.0e-6
idt.a=96.0e-9
if __name__=="__main__":
print get_tag(qdt, "a", "unit")
print qdt.latex_table()
from taref.plotter.fig_format import Plotter
from taref.physics.fundamentals import sinc, sinc_sq
b=Plotter()
from numpy import linspace, pi, absolute, sqrt, sin
freq=linspace(1e9, 10e9, 1000)
#qdt.ft="single"
#qdt.get_member("mult").reset(qdt)
#qdt.get_member("lbda0").reset(qdt)
print qdt.f0, qdt.G_f0
if 0:
#G_f=(1.0/sqrt(2.0))*0.5*qdt.Np*qdt.K2*qdt.f0*absolute(sinc(qdt.Np*pi*(freq-qdt.f0)/qdt.f0))
#b.line_plot("sinc", freq, G_f, label="sinc/sqrt(2)")
#G_f=0.5*qdt.Np*qdt.K2*qdt.f0*absolute(sinc(qdt.Np*pi*(freq-qdt.f0)/qdt.f0))
def synchronize(self):
tlist=[param for param in self.main_params if get_tag(self, param, 'get_cmd') is not None]
for cmd in set(tlist):
self.receive(param)
self.wait_loop(self.resp_delay)
print 'set_tag(t, "a", z="p")'
set_tag(t, "a", z="p")
print 'print t.get_member("a").metadata'
print t.get_member("a").metadata
print 'print t.get_member("b").metadata'
print t.get_member("b").metadata
print
print 'set_all_tags(t, z=True)'
set_all_tags(t, z=True)
print 'print t.get_member("a").metadata'
print t.get_member("a").metadata
print 'print t.get_member("b").metadata'
print t.get_member("b").metadata
print
print 'get_tag(t, "a", "tg", "five")'
print get_tag(t, "a", "tg", "five")
print 'get_tag(t, "b", "tg", "five")'
print get_tag(t, "b", "tg", "five")
print 'get_tag(t, "a", "tg")'
print get_tag(t, "a", "tg")
print 'get_tag(t, "b", "tg")'
print get_tag(t, "b", "tg")
print
log_info("test code:")
class Test(Atom):
a = Int().tag(tg=4)
b = Float()
c = Unicode("blah").tag(tg=4)
d = Bool().tag(tg=5)
def plot_set(self, param):
for clt in self.clt_values():
simple_set(clt, self, get_tag(self, param, "former", param))
def send_log(self, name):
"""Log for sending. can be overwritten in child classes to allow customization of message"""
label=get_tag(self, name, 'label', name)
print "SEND: {instr} {label}".format(instr=self.name, label=label)
def nosend_context(self, name):
"""context that temporarily turns off auto sending for it's duration"""
temp=get_tag(self, name, 'send_now', self.send_now)
safe_set_tag(self, name, send_now=False)
yield
safe_set_tag(self, name, send_now=temp)
def booter(self, address, delay, timeout, reset, selftest, lock, send_end, identify, clear, header):
start_GPIB(self, address, delay, timeout, reset, selftest,
lock, send_end, identify, clear)
sleep(0.05)#yoko crashes if this pause isn't after the clear
if get_tag(self, "header", "do", False):
self.header.send()
def append_valcom(self, inlist, name, fmt_str="{0}{1}", sep=";"):
comment=format_comment(get_tag(self, name, "comment", ""))
value=getattr(self, name)
inlist.append(fmt_str.format(value, comment))
if __name__ == "__main__":
from taref.core.shower import shower
a = IDT()
b = IDT()
log_debug(a.K2, b.K2)
a.Dvv = 5
print a._get_Dvv(4)
log_debug(a.get_member("K2").fget.fset_list)
log_debug(a.get_member("K2").fset(a, 3))
log_debug(a.get_member("K2").fset)
print a.K2, b.K2
for param in a.all_params:
print get_tag(a, param, "unit")
shower(a)
print a.call_func(
"eta", a=0.2e-6,
g=0.8e-6) #, vf=array([500.0, 600.0]), lbda0=array([0.5e-6, 0.6e-6]))
a.plot_data("f0", lbda0=linspace(0.1e-6, 1.0e-6, 10000))
print a.get_tag("lbda0", "unit_factor")
show()
if 1:
print a.K2, a.Dvv
#print dir(a.get_member("K2").fget.fset)
a.K2 = 5
a.Dvv = 5
print a.K2
shower(a)
#print a.K2, a.Dvv
def receive_log(self, name):
"""Log for receiving. can be overwritten in child classes for customization of message"""
label=get_tag(self, name, 'label', name)
print "RECEIVE: {instr} {label}".format(instr=self.name, label=label)
