def create_test_shot(shot_number, tree_name=TEST_TREE_NAME):
"""Create a shot using all of the MDSplus data types.
Note: this is incomplete, so not all datatypes are present yet.
"""
t = MDSplus.Tree(tree_name, shot_number, mode="NEW")
t.addNode('node_A')
t.addNode('node_B')
node_a = t.getNode('node_A')
node_a.setUsage("SIGNAL")
node_a.addTag("tag_A")
node_a.addNode('node_AA')
node_a.addNode('node_AB')
sig = MDSplus.Signal(MDSplus.makeArray(numpy.random.poisson(lam=10, size=SIGNAL_LENGTH)),
None, MDSplus.makeArray(0.1*numpy.arange(SIGNAL_LENGTH)))
node_a.putData(sig)
node_aa = t.getNode('\\test::top.node_A.node_AA')
node_aa.addTag("tag_AA")
node_aa.addNode("node_AAA")
node_ab = t.getNode('\\test::top.node_A.node_AB')
str_data = MDSplus.StringArray(["elmt1", "elmt2"])
node_ab.putData(str_data)
t.setCurrent('test', shot_number)
t.write()
def start(self):
def validate(node, value):
node.write_once = node.no_write_shot = False
try:
node.record = node.record.setValidation(value)
finally:
node.write_once = node.no_write_shot = True
def store_temp(node, new):
if isinstance(new, (float, )):
node.record = MDSplus.Float64([new])
elif isinstance(new, (int, )):
node.record = MDSplus.Uint32([new])
try:
validate(self.frame_rate,
MDSplus.Float32(self.cygnet4k.frame_rate))
validate(self.exposure,
MDSplus.Float32(self.cygnet4k.exposure))
validate(self.trig_mode,
MDSplus.Uint8(self.cygnet4k.trig_mode))
validate(self.binning, MDSplus.Int8(self.cygnet4k.binning))
validate(self.roi_rect, MDSplus.Int16(self.cygnet4k.roi_rect))
aoi = self._roi_rect
cmos, pcb = self.cygnet4k.start_capture_stream(
self._num_frames, aoi, self._stream, self.frames,
self.frames_max)
store_temp(self.temp_cmos, cmos)
store_temp(self.temp_pcb, pcb)
except CygnetExcConnect:
raise MDSplus.DevOFFLINE
except CygnetExcValue:
raise MDSplus.DevINV_SETUP
except CygnetExcComm:
raise MDSplus.DevIO_STUCK
def testmds(expt='test', shot=1):
import gc
gc.collect()
MDSplus.setenv('test_path', '/tmp')
from LocalDevices.cygnet4k import CYGNET4K
with MDSplus.Tree(expt, shot, 'NEW') as t:
dev = CYGNET4K.Add(t, "CYGNET4K")
t.write()
dev.conf_file.no_write_shot = False
dev.conf_file = "/etc/xcap_cygnet4k.fmt"
dev.roi_rect.no_write_shot = False
dev.roi_rect = MDSplus.Int32([500, 500, 1000, 1000])
old = MDSplus.Device.debug
MDSplus.Device.debug = 0 #max(1,old)
t.open()
try:
dev.init()
sleep(1)
dev.start()
sleep(1)
dev.stop()
finally:
dev.deinit()
print(dev.frames_max.getRecord(None))
t.close()
MDSplus.Device.debug = old
def evaluate_data(node):
try:
segszs=(1000, 100)
for n in node.getMembers():
name = n.getNodeName()
sig = getSignal(name,True)
if name.startswith("SEG"):
m.tcl('SET NODE %s /COMPRESS_SEGMENTS' % n.getPath())
data= sig.data()
dims= sig.dim_of().data()
duns= sig.dim_of().units
segsz = segszs[data.ndim] if data.ndim<2 else 1
for i in range(int(data.shape[0]/segsz)):
ft = (i*segsz,(i+1)*segsz)
img = data[ft[0]:ft[1]]
dim = m.Dimension(None,dims[ft[0]:ft[1]])
dim.setUnits(duns)
n.makeSegment(dims[ft[0]],dims[ft[1]-1],dim,img)
# n.setUnits(sig.units)
# n.setHelp(sig.getHelp())
else:
n.putData(sig)
name = None
finally:
if name is not None:
print(name)
def addfun(name,code,_file_=__file__):
"""
can be used to add customized python functions to the tdi environment
e.g.:
>>> ADDFUN("myfun","def myfun(a): print(a)")
"MYFUN"
>>> MYFUN(3)
3
*
in order to prevent the function to load more than once use:
>>> IF_ERROR(PUBLIC("MYFUN2"),ADDFUN("myfun2","def myfun2(a): print(a)"))
"MYFUN2"
"""
name = str( name .data() if isinstance( name ,MDSplus.Data) else name )
_file_ = str(_file_.data() if isinstance(_file_,MDSplus.Data) else _file_)
mdsname = name.upper()
if not modulename in sys.modules:
sys.modules[modulename] = types.ModuleType(modulename)
code = MDSplus.Data.data(code)
env = {}
exec(compile(code,"TDI/%s"%(name,),'exec'),env,env)
module_dict = sys.modules[modulename].__dict__
module_dict[mdsname] = env[name]
module_dict["__file__%s"%mdsname] = _file_
mdsname = MDSplus.String(mdsname)
return MDSplus.EQUALS(MDSplus.PUBLIC(mdsname),mdsname).evaluate()
def main(argv):
timesleep = 60 #secs
tree = MDSplus.Tree('daqtest', -1)
node = tree.ACQ_161.NODE.data()
print("Open daqtest tree {} {}".format(tree, node))
tree = MDSplus.Tree('daqtest', -1)
time.sleep(1)
shot = int(sys.argv[1])
print("Shot # {}".format(shot))
tree.setCurrent(shot)
tree.createPulse(0)
tree = MDSplus.Tree('daqtest', 0)
tree.ACQ_161.init()
for remaining in range(timesleep, 0, -1):
sys.stdout.write("\r")
sys.stdout.write("{:2d} seconds remaining.".format(remaining))
sys.stdout.flush()
time.sleep(1)
sys.stdout.write("\n\rShot Complete!\n")
tree.ACQ_161.stop()
tree.close()
time.sleep(5)
def evaluate_data(node):
try:
segszs = (1000, 100)
for n in node.getMembers():
name = n.getNodeName()
sig = getSignal(name, True)
if name.startswith("SEG"):
m.tcl('SET NODE %s /COMPRESS_SEGMENTS' % n.getPath())
data = sig.data()
dims = sig.dim_of().data()
duns = sig.dim_of().units
segsz = segszs[data.ndim] if data.ndim < 2 else 1
for i in range(int(data.shape[0] / segsz)):
ft = (i * segsz, (i + 1) * segsz)
img = data[ft[0]:ft[1]]
dim = m.Dimension(None, dims[ft[0]:ft[1]])
dim.setUnits(duns)
n.makeSegment(dims[ft[0]], dims[ft[1] - 1], dim, img)
# n.setUnits(sig.units)
# n.setHelp(sig.getHelp())
else:
n.putData(sig)
name = None
finally:
if name is not None:
print(name)
def create_tree(tree_path):
if not os.path.exists(tree_path):
os.mkdir(tree_path)
os.environ["test_path"] = tree_path
for shot_number in xrange(1, 4):
t = MDSplus.Tree("test", shot_number, mode="NEW")
t.addNode("node_A")
t.addNode("node_B")
node_a = t.getNode("node_A")
node_a.setUsage("SIGNAL")
node_a.addTag("tag_A")
node_a.addNode("node_AA")
node_a.addNode("node_AB")
mds_arr = MDSplus.makeArray(numpy.random.poisson(lam=10, size=SIGNAL_LENGTH))
mds_dim = MDSplus.makeArray(0.1 * numpy.arange(SIGNAL_LENGTH))
sig = MDSplus.Signal(mds_arr, None, mds_dim)
node_a.putData(sig)
node_aa = t.getNode("\\test::top.node_A.node_AA")
node_aa.addTag("tag_AA")
node_aa.addNode("node_AAA")
t.setCurrent("test", shot_number)
t.write()
def setNode(treename='test', shot=3):
import MDSplus
with MDSplus.Tree(treename, shot) as tree:
node = tree.getNode('opt')
MDSplus.TdiExecute('_time=*')
node.putData(
MDSplus.TdiCompile(b'opttest($,IF_ERROR(_time,*))', (node, )))
def addField(node,name,v):
k = _sup.fixname12(name)
if isinstance(v, (_ver.basestring, )):
pn = node.addNode(k, 'TEXT').putData(_ver.tobytes(v))
elif isinstance(v, (int, float)):
pn = node.addNode(k, 'NUMERIC').putData(v)
elif isinstance(v, (list,)):
if isinstance(v[0], _ver.numbers):
pn = node.addNode(k, 'NUMERIC').putData(_mds.makeArray(v))
else:
pn = node.addNode(k, 'ANY').putData(v)
elif isinstance(v, (dict,)):
if '['+str(len(v)-1)+']' in v.keys():
v = [v['['+str(i)+']'] for i in _ver.xrange(len(v))]
if all(isinstance(vi, _ver.numbers) for vi in v):
pn = node.addNode(k, 'NUMERIC').putData(_mds.makeArray(v))
else:
try:
pn = node.addNode(k, 'ANY').putData(v)
except:
pn.putData([str(i) for i in v])
else:
try:
pn = node.addNode(k,'TEXT')
for vk,vv in v.items():
addField(pn,vk,vv)
try: pn.setUsage('STRUCTURE')
except: _sup.debug(pn.minpath,2)
except:
pn.putData(str(v))
pn.addNode('$NAME','TEXT').record = name
def storeChannel(self, chan, chanMask, preTrig, postTrig, clock, vins):
if self.debugging():
print "working on channel %d" % chan
chan_node = self.__getattr__('input_%2.2d' % (chan + 1, ))
if chan_node.on:
if self.debugging():
print "it is on so ..."
if chanMask[chan:chan + 1] == '1':
try:
start = max(
int(
self.__getattr__('input_%2.2d_startidx' %
(chan + 1, ))), -preTrig)
except:
start = -preTrig
try:
end = min(
int(
self.__getattr__('input_%2.2d_endidx' %
(chan + 1, ))), postTrig - 1)
except:
end = postTrig - 1
try:
inc = max(
int(self.__getattr__('input_%2.2d_inc' %
(chan + 1, ))), 1)
except:
inc = 1
#
# could do the coeffs
#
if self.debugging():
print "about to readRawData(%d, preTrig=%d, start=%d, end=%d, inc=%d)" % (
chan + 1, preTrig, start, end, inc)
try:
buf = self.readRawData(chan + 1, preTrig, start, end, inc,
False)
if self.debugging():
print "readRawData returned %s\n" % (type(buf), )
if inc == 1:
dim = MDSplus.Dimension(
MDSplus.Window(start, end, self.trig_src), clock)
else:
dim = MDSplus.Dimension(
MDSplus.Window(start / inc, end / inc,
self.trig_src),
MDSplus.Range(None, None,
clock.evaluate().getDelta() * inc))
dat = MDSplus.Data.compile(
'build_signal(build_with_units((($1+ ($2-$1)*($value - -32768)/(32767 - -32768 ))), "V") ,build_with_units($3,"Counts"),$4)',
vins[chan * 2], vins[chan * 2 + 1], buf, dim)
exec('c=self.input_' + '%02d' % (chan + 1, ) +
'.record=dat')
except Exception, e:
print "error processing channel %d\n%s\n" % (
chan + 1,
e,
)
def run(self):
def lcm(a,b):
from fractions import gcd
return (a * b / gcd(int(a), int(b)))
def lcma(arr):
ans = 1.
for e in arr:
ans = lcm(ans, e)
return int(ans)
if self.dev.debug:
print("MDSWorker running")
event_name = self.dev.seg_event.data()
trig = self.dev.trigger.data()
if self.dev.hw_filter.length > 0:
dt = 1./self.dev.freq.data() * 2 ** self.dev.hw_filter.data()
else:
dt = 1./self.dev.freq.data()
decimator = lcma(self.decim)
if self.seg_length % decimator:
self.seg_length = (self.seg_length // decimator + 1) * decimator
self.dims = []
for i in range(self.nchans):
self.dims.append(MDSplus.Range(0., (self.seg_length-1)*dt, dt*self.decim[i]))
self.device_thread.start()
segment = 0
first = True
running = self.dev.running
max_segments = self.dev.max_segments.data()
while running.on and segment < max_segments:
try:
buf = self.full_buffers.get(block=True, timeout=1)
except Queue.Empty:
continue
buffer = np.right_shift(np.frombuffer(buf, dtype='int32') , 8)
i = 0
for c in self.chans:
if c.on:
b = buffer[i::self.nchans*self.decim[i]]
c.makeSegment(self.dims[i].begin, self.dims[i].ending, self.dims[i], b)
self.dims[i] = MDSplus.Range(self.dims[i].begin + self.seg_length*dt, self.dims[i].ending + self.seg_length*dt, dt*self.decim[i])
i += 1
segment += 1
MDSplus.Event.setevent(event_name)
self.empty_buffers.put(buf)
self.dev.trig_time.record = self.device_thread.trig_time - ((self.device_thread.io_buffer_size / np.int32(0).nbytes) * dt)
self.device_thread.stop()
def _pre_store(self):
board_addr = self._get_board_addr()
board_site = self._get_board_site()
uut_sys = UUT(board_addr, self._sys_port, debug=self._debugging())
uut_mod = UUT(board_addr,
self._sys_port + board_site,
debug=self._debugging())
# check if arming was performed in a different shot
if self.tree.shot != int(uut_mod.send('shot')):
raise MDSplus.mdsExceptions.DevWRONG_SHOT
# check if device is still armed
nums = uut_sys.send('state').split(' ')
state = int(nums[0])
if state == 1 or state == 2:
raise MDSplus.mdsExceptions.DevNOT_TRIGGERED(
'device was armed but not triggered')
# wait for STOP
for i in range(self._store_retries):
if state == 0:
break
time.sleep(1)
nums = uut_sys.send('state').split(' ')
state = int(nums[0])
if state != 0:
print('warning: device not ready')
# read samples
pre_trig = int(nums[1])
post_trig = int(nums[2])
if pre_trig + post_trig == 0:
print('error: device was not armed')
raise MDSplus.mdsExceptions.DevNOT_TRIGGERED(
'device was not armed')
# read and store clocks
intclk = float(uut_mod.send('sysclkhz'))
mbclk = float(uut_sys.send('SIG:CLK_MB:FREQ').split(' ')[1])
clk = float(
uut_sys.send('SIG:CLK_S%d:FREQ' % board_site).split(' ')[1])
try:
self.int_clock.record = MDSplus.Range(None, None, 1. / intclk)
self.sys_clock.record = MDSplus.Range(None, None, 1. / mbclk)
# TODO: handle module internal clock
self.clock.record = MDSplus.Range(None, None, 1. / clk)
except MDSplus.mdsExceptions.TreeNOOVERWRITE:
print('warning: retrying store method')
# compute channel offset due to lower-numbered sites
offset = 0
for i in range(1, board_site):
offset += int(uut_sys.send('get.site %d NCHAN' % i))
if self._debugging():
print(('pre_store(): channel offset = %d' % offset))
return (pre_trig, post_trig, offset)
def get_mds_active_probes(shot, tunnel=True):
"""
Get the probes that were active during the shot. Used in main function.
shot: the shot you want
"""
# MDSplus connection to atlas where the data is store on the "LANGMUIR" tree.
if tunnel:
conn = mds.Connection("localhost")
else:
conn = mds.Connection('atlas.gat.com')
conn.openTree("LANGMUIR", shot)
tmin = conn.get("\LANGMUIR::TOP.TMIN").data()
tmax = conn.get("\LANGMUIR::TOP.TMAX").data()
runid = conn.get("\LANGMUIR::TOP.RUNID").data()
mds_index = []
found_probes = []
for mds_pnum in range(1, 85):
# Make sure probe name is in correct formart: 001, 002, ... , 084, 085.
if mds_pnum < 10:
probe = "00" + str(mds_pnum)
else:
probe = "0" + str(mds_pnum)
# The complete path name to the lp. PNUM is the probe number, which does
# not match its number in mdsplus (001 - 085).
pname = "\LANGMUIR::TOP.PROBE_" + probe + ".PNUM"
# Get the actual probe number if it is there. Not all MDS probes are used.
try:
check_pnum = conn.get(pname).data()
except:
pass
#print "No data in probe " + str(probe) + "."
# It will be '0' or blank if the MDS entry isn;t used. Otherwise it will
# have the actual probe number in it.
if check_pnum > 0:
print("Probe " + str(check_pnum) + " is MDS probe " +
str(mds_pnum))
mds_index.append(mds_pnum)
found_probes.append(check_pnum)
number_of_probes = len(found_probes)
print("Found data for " + str(number_of_probes) + " probes.")
# Store in dictionary and return it.
active = {}
active["tmin"] = tmin
active["tmax"] = tmax
active["runid"] = runid
active["probes"] = found_probes
active["mds_index"] = mds_index
return active
def _stream(dim, data, node, nodemax):
nodemax.makeSegment(dim, dim, MDSplus.Float32([dim]),
MDSplus.Uint16([numpy.max(data)]))
if MDSplus.Device.debug:
print('storeFrame: %s, %s, %s' %
(node.minpath, dim, data.shape))
dims = MDSplus.Float32([dim]).setUnits('s')
data = MDSplus.Uint16([data])
node.makeSegment(dim, dim, dims, data)
def run(self):
def lcm(a,b):
from fractions import gcd
return (a * b / gcd(int(a), int(b)))
def lcma(arr):
ans = 1.
for e in arr:
ans = lcm(ans, e)
return int(ans)
if self.dev.debug:
print("MDSWorker running")
event_name = self.dev.seg_event.data()
trig = self.dev.trigger.data()
if self.dev.hw_filter.length > 0:
dt = 1./self.dev.freq.data() * 2 ** self.dev.hw_filter.data()
else:
dt = 1./self.dev.freq.data()
decimator = lcma(self.decim)
self.device_thread.start()
segment = 0
begin = 0.0
first = True
running = self.dev.running
max_segments = self.dev.max_segments.data()
while running.on and segment < max_segments:
try:
buf = self.full_buffers.get(block=True, timeout=1)
except Empty:
continue
buffer = np.right_shift(np.frombuffer(buf, dtype='int32') , 8)
i = 0
for c in self.chans:
if c.on:
b = buffer[i::self.nchans*self.decim[i]]
dim_limits=[begin, begin + self.seg_length*dt - 1]
cull_dim =MDSplus.CULL(dim_limits, None, MDSplus.Range(begin, begin + self.seg_length*dt -1, dt*self.decim[i]))
c.makeSegment(begin, begin + self.seg_length*dt, cull_dim, b)
i += 1
segment += 1
begin += self.seg_length*dt
MDSplus.Event.setevent(event_name)
self.empty_buffers.put(buf)
self.dev.trig_time.record = self.device_thread.trig_time - ((self.device_thread.io_buffer_size / np.int32(0).nbytes) * dt)
self.device_thread.stop()
def tdiPythonInterface(self):
self._doTdiTest("Py('a=None')", 1)
self._doTdiTest("Py('a=None','a')", None)
self._doTdiTest("Py('a=123','a')", 123)
self._doTdiTest("Py('import MDSplus;a=MDSplus.Uint8(-1)','a')",
m.Uint8(255))
self._doTdiTest("pyfun('Uint8','MDSplus',-1)", m.Uint8(255))
self._doTdiTest("pyfun('Uint8',*,-1)", m.Uint8(255))
self._doTdiTest("pyfun('str',*,123)", m.String("123"))
def getVSP(shot):
VSP = []
VSP += [
MDSplus.Tree('dtacq0', shot).getNode('.CH93').getData().data().mean()
]
VSP += [
MDSplus.Tree('dtacq0', shot).getNode('.Ch94').getData().data().mean()
]
return VSP
def difftree(treename1, shot1, treename2, shot2, exclude):
import MDSplus as _mds
"""
dd = difftree('W7X', -1, 'W7X', 100, '\ARCHIVE::TOP')
pprint(dd[0])
"""
treedict1 = treeToDict(_mds.Tree(treename1, shot1), exclude)
treedict2 = treeToDict(_mds.Tree(treename2, shot2), exclude)
treediff = DeepDiff(treedict1, treedict2)
return treediff, _sup.obj(treedict1), _sup.obj(treedict2)
def sendU(self):
if self.sim_index >= len(self.u):
self.sim_index = 0
self.sim_time = 0.0
MDSplus.Event.stream(0, 'U', MDSplus.Float32(self.sim_time),
MDSplus.Float64(self.u[self.sim_index]))
self.ui.Ulabel.setText(str(self.u[self.sim_index]))
self.sim_index += 1
self.ui.UNextlabel.setText(str(self.u[self.sim_index]))
self.sim_time += .01
def writedata(data, dims, nodepath, expt, shot):
""" data: list of images """
""" dims: array of double seconds based on T1 """
tree = _mds.Tree(expt, shot)
node = tree.getNode(nodepath)
node.deleteData()
for i in range(len(data)):
dim = _mds.Float64Array(dims[i])
dim.setUnits('s')
node.makeSegment(dims[i], dims[i], dim, _mds.makeArray(data[i]), -1)
def dicttotree(dic, node):
for k, v in dic.items():
print(node.getPath() + ':' + k[0:12])
newnode = node.getNode(k[0:12])
if isinstance(v, dict):
dicttotree(v, newnode)
elif isinstance(v, (tuple, list)):
newnode.putData(_mds.makeArray(v))
else:
newnode.putData(_mds.makeScalar(v))
def dicttotree(dic, node):
for k,v in dic.items():
print(node.getPath()+':'+k[0:12])
newnode = node.getNode(k[0:12])
if isinstance(v, dict):
dicttotree(v, newnode)
elif isinstance(v, (tuple, list)):
newnode.putData(_mds.makeArray(v))
else:
newnode.putData(_mds.makeScalar(v))
def modECE(tree='archive', shot=-1):
with _mds.Tree(tree, shot, 'edit') as arc:
stream = arc.CDSD16007.DRPD17547
for i in range(32):
node = stream.getNode('CH%d' % i)
try:
ece = node.addNode('$ECE', 'SIGNAL')
except:
ece = node.getNode('$ECE')
ece.record = _mds.TdiCompile('ECE($)', (node, ))
arc.write()
def _stream(dim, data, dev):
dev.tree.open()
dev.frames_percentile.makeSegment(
dim, dim, MDSplus.Float32([dim]),
MDSplus.Uint16([numpy.percentile(data, 99)]))
if MDSplus.Device.debug & 1:
print('storeFrame: %s, %s, %s' %
(dev.minpath, dim, data.shape))
dims = MDSplus.Float32([dim]).setUnits('s')
data = MDSplus.Uint16([data])
dev.frames.makeSegment(dim, dim, dims, data)
def getSubTrees(expt='W7X',
shot=-1,
excludelist=('ARCHIVE', ),
excludereg=('.*_EVAL', )):
rematch = tuple(_re.compile(reg) for reg in excludereg)
tree = _mds.Tree(expt, shot)
subtrees = [
_mds.TreeNode(c.nid, tree) for c in tree.top.getChildren()
if c.usage == 'SUBTREE' and not (c.node_name in excludelist)
and all(re.match(str(c.node_name)) is None for re in rematch)
]
return subtrees
def toMds(self):
if not self.amend:
Model = mds.Tree('tcv_topic21')
Model.createPulse(self.shot)
del Model
self.saveTree = mds.Tree('tcv_topic21', self.shot)
if not self.amend:
self._Lp2Mds()
self._Lambda2Mds()
self._Fp2Mds()
self.saveTree.quit()
def decompile(self):
self.assertEqual(str(m.Uint8(123)), '123BU')
self.assertEqual(str(m.Uint16(123)), '123WU')
self.assertEqual(str(m.Uint32(123)), '123LU')
self.assertEqual(str(m.Uint64(123)), '123QU')
self.assertEqual(str(m.Int8(123)), '123B')
self.assertEqual(str(m.Int16(123)), '123W')
self.assertEqual(str(m.Int32(123)), '123')
self.assertEqual(str(m.Int64(123)), '123Q')
self.assertEqual(
str(m.Signal(m.ZERO(100000, 0).evaluate(), None, 0)),
"Build_Signal(Set_Range(100000,0 /*** etc. ***/), *, 0)")
def store(self):
event_name = self.data_event.data()
if self.t2.rlength == 0:
self.t2.record = MDSplus.Int64(time.time() * 1000.)
trend_tree = self.getTrendTree()
trend_dev = trend_tree.getNode(self.trend_device.data())
# Getting T1 from TREND:
t1 = MDSplus.Int64(self.t1.data() * 1000.)
#Saving TREND shot number information into the tree:
self.trend_shot.record = trend_tree.getCurrent(self.trend_tree.data())
#Set Time Context
trend_tree.setTimeContext(t1, self.t2.data())
print('Writing data into shot node')
for i in self.inputs():
trend_temp = trend_dev.__getattr__('input_%c' % (chr(i)))
trend_resis = trend_dev.__getattr__('input_%c_resistence' %
(chr(i)))
times = trend_temp.dim_of().data()
temps = trend_temp.data()
resists = trend_resis.data()
# Might be able to improve
start_time = times[0]
for j in range(len(times)):
times[j] -= start_time
times[j] = float(times[j]) / 1000.
shot_temp = self.__getattr__('input_%c' % (chr(i)))
shot_resis = self.__getattr__('input_%c_resistence' % (chr(i)))
shot_temp.record = MDSplus.Signal(temps, None, times)
shot_resis.record = MDSplus.Signal(resists, None, times)
for i in self.loops():
trend_outpower = trend_dev.__getattr__('loop_%c' % (str(i + 1)))
times = trend_outpower.dim_of().data()
outpower = trend_outpower.data()
start_time = times[0]
for j in range(len(times)):
times[j] -= start_time
times[j] = float(times[j]) / 1000.
shot_outpower = self.__getattr__('loop_%c' % (str(i + 1)))
shot_outpower.record = MDSplus.Signal(outpower, None, times)
MDSplus.Event.setevent(event_name)
def get_mds_lp_data(shot, mds_index, tunnel=True):
"""
Get LP data for a single probe. Used in main function.
shot: the shot you want
mds_index: a number 1-85 that corresponds to the mds node. These do not
match the probe number (which is PNUM).
"""
# MDS connection required through atlas tunnel.
if tunnel:
conn = mds.Connection("localhost")
else:
conn = mds.Connection("atlas.gat.com")
conn.openTree("LANGMUIR", shot)
# Use correct form of probe name.
if mds_index < 10:
probe = "00" + str(mds_index)
else:
probe = "0" + str(mds_index)
pname = "\LANGMUIR::TOP.PROBE_" + probe
# All the data stored in a dictionary. All the data is in the subtree
# indicated in pname. Just specify the node and grab the data.
lp_data = {}
lp_data["time"] = conn.get(pname + ":TIME").data()
lp_data["rprobe"] = conn.get(pname + ":R").data()
lp_data["zprobe"] = conn.get(pname + ":Z").data()
lp_data["label"] = conn.get(pname + ":LABEL").data()
lp_data["ntimes"] = conn.get(pname + ":NTIMES").data()
lp_data["pnum"] = conn.get(pname + ":PNUM").data()
lp_data["isat"] = conn.get(pname + ":ISAT").data()
lp_data["jsat"] = conn.get(pname + ":JSAT").data()
lp_data["temp"] = conn.get(pname + ":TEMP").data()
lp_data["dens"] = conn.get(pname + ":DENS").data()
lp_data["pot"] = conn.get(pname + ":POT").data()
lp_data["psin"] = conn.get(pname + ":PSIN").data()
lp_data["angle"] = conn.get(pname + ":ANGLE").data()
lp_data["area"] = conn.get(pname + ":AREA").data()
lp_data["delrsepout"] = conn.get(pname + ":DELRSEPOUT").data()
lp_data["delrsepin"] = conn.get(pname + ":DELRSEPIN").data()
lp_data["delzsepout"] = conn.get(pname + ":DELZSEPOUT").data()
lp_data["delzsepin"] = conn.get(pname + ":DELZSEPIN").data()
lp_data["csq"] = conn.get(pname + ":CSQ").data()
lp_data["res_err"] = conn.get(pname + ":RES_ERR").data()
lp_data["heatflux"] = conn.get(pname + ":HEATFLUX").data()
lp_data["pnum"] = conn.get(pname + ":PNUM").data()
#print "Data stored for probe " + str(lp_data["pnum"]) + " (MDS index " + str(mds_index) + ")."
return lp_data
def update(node, new):
if isinstance(new, (float, )): new = MDSplus.Float32(new)
elif isinstance(new, (int, )): new = MDSplus.Uint16(new)
else: return
rec = node.getRecord(None)
if rec is None: rec = MDSplus.Array([new, new])
elif len(rec) != 1: return
else: rec = MDSplus.Array([rec[0], new])
node.write_once = node.no_write_shot = False
try:
node.record = rec
finally:
node.write_once = node.no_write_shot = True
def handle(self):
data = self.request.recv(1024)
#cur_thread = threading.current_thread()
com = data[0]
param = data[1:]
response = ''
print(("Request ", data))
if com == 'c': # connection request
tree, shot, node = param.split(',')
try:
self.t = MDSplus.Tree(tree, int(shot))
tn = self.t.getNode(node)
self.t.setDefault(tn)
response = 'ok'
except Exception:
response = str(sys.exc_info()[1]) + ',' + str(
sys.exc_info()[2])
if com == 'f': # connection request
a = param.split(',')
tree = a[0]
shot = a[1]
node = a[2]
expr = ','.join(a[3:])
try:
self.t = MDSplus.Tree(tree, int(shot))
if node.strip() != '':
tn = self.t.getNode(node)
self.t.setDefault(tn)
r = MDSplus.Data.compile(expr).evaluate().data()
sr = pickle.dumps(r)
response = binascii.b2a_hex(sr)
print(("sending data (length)", len(response), 'original :',
type(sr)))
print(type(binascii.a2b_hex(response)))
except Exception:
response = str(sys.exc_info()[1]) + ',' + str(
sys.exc_info()[2])
if com == 'v': # mdsvalue
r = MDSplus.Data.compile(param).evaluate().data()
sr = pickle.dumps(r)
response = binascii.b2a_hex(sr)
print(("sending data (length)", len(response), 'original :',
type(sr)))
print(type(binascii.a2b_hex(response)))
#response = "{}: {}".format(cur_thread.name, data)
self.request.sendall(response + '\n')
def tdiPythonInterface(self):
self._doTdiTest("Py('a=None')",1)
self._doTdiTest("Py('a=None','a')",None)
self._doTdiTest("Py('a=123','a')",123)
self._doTdiTest("Py('import MDSplus;a=MDSplus.Uint8(-1)','a')",m.Uint8(255))
self._doTdiTest("pyfun('Uint8','MDSplus',-1)",m.Uint8(255))
self._doTdiTest("pyfun('Uint8',*,-1)",m.Uint8(255))
self._doTdiTest("pyfun('str',*,123)",m.String("123"))
self._doTdiTest('_l=list(*,1,2,3)', m.List([1,2,3]))
self._doTdiTest('_l=list(_l,4,5)', m.List([1,2,3,4,5]))
self._doTdiTest('apdrm(_l,1,3)', m.List([1,3,5]))
self._doTdiTest('_d=dict(*,1,"1",2,"2")', m.Dictionary([1,'1',2,'2']))
self._doTdiTest('_d=dict(_d,3,"3")', m.Dictionary([1,'1',2,'2',3,"3"]))
self._doTdiTest('apdrm(_d,2)', m.Dictionary([1,'1',3,"3"]))
def storeChannel(self, name, chan, addr, pts, gain, offset):
import MDSplus
chan_node = self.__getattr__('input_%1.1d' % (chan + 1, ))
if chan_node.on:
if self.debug:
print("it is on so ...")
start = 0
end = pts - 1
try:
start = max(
int(
self.__getattr__('input_%1.1d_start_idx' %
(chan + 1, ))), 0)
except:
pass
try:
end = min(
int(self.__getattr__('input_%1.1d_end_idx' %
(chan + 1, ))), pts - 1)
except:
pass
if self.debug:
print("about to aeon_getchannel(%s, %d, %d %d)" % (
name,
addr,
chan,
end + 1,
))
buf = MDSplus.Data.execute('aeon_getchannel("%s", %d, %d, %d)' % (
name,
addr,
chan,
end + 1,
))
dim = MDSplus.Dimension(MDSplus.Window(start, end, self.trigger),
self.clock)
if self.debug:
print("about to make dat")
print("gain = %d" % gain)
print("offset =%d" % offset)
print("dim is %s" % str(dim))
print("start is %d end is %d" % (
start,
end,
))
dat = MDSplus.Data.compile(
'build_signal(build_with_units(($value - $2)*.02/$1, "V") ,build_with_units($3,"Counts"),$4)',
gain, offset, buf[start:end], dim)
exec('c=self.input_' + '%1d' % (chan + 1, ) + '.record=dat')
def __init__(self, shot, gas='D2', Lp='Div'):
"""
Parameters
----------
shot :
Shot number
gas :
String indicating the gas. 'D2','H','He'
Lp :
String indicating if the parallel connection
length should be considered from target to
midplane 'Mid' or from target to X-point
'Div'
"""
self.shot = shot
self.Lp = Lp
# globally define the gas
self.gas = gas
if gas == 'D2':
self.Z = 1
self.mu = 2
elif gas == 'H':
self.Z = 1
self.mu = 1
elif gas == 'He':
self.Z = 4
self.mu = 4
else:
print('Gas not found, assuming Deuterium')
self.gas = 'D2'
self.Z = 1
self.mu = 2
# equilibrium quantities
self._eq = eqtools.TCVLIUQETree(self.shot)
# this is the iP in the time bases of LIUQE
self._tLiuqe = self._eq.getTimeBase()
self.BtSign = np.sign(self._eq.getBtVac().mean())
# now define the tree where the probe data are saved
self._filament = mds.Tree('tcv_topic21', shot)
# this is for different quantities
self._tree = mds.Tree('tcv_shot', shot)
# this can be done one single time and then accordingly
# to analysis region we choose the appropriate timing
try:
self.Target = langmuir.LP(self.shot)
except:
print('Langmuir probe data not found')
self.Target = None
def createSignal(dat, dim, t0, unit=None, addim=[], units=[], help=None, value=None, scaling=None,**kwargs):
def _dim(time,t0):
if len(time):
t0 = _mds.Int64(t0)
time = _mds.Int64Array(time)
if t0==0:
unit = 'ns'
else:
time = _mds.Float64(time-t0)*1E-9
unit = 's'
wind = _mds.Window(time[0], time[time.shape[0]-1], t0)
dim = _mds.Dimension(wind, time)
dim.setUnits(unit)
return dim
else:
return _mds.EmptyData()
def _addim(dim, units='unknown'):
if len(dim):
dim = _mds.Dimension(None, tonumpy(dim))
dim.setUnits(Units(units))#
return dim
else:
return None
if isinstance(dat, (list,)):
dat = tonumpy(dat)
dat = _mds.makeArray(dat)
dim = _dim(dim,t0)
for i in _ver.xrange(len(addim)):
addim[i] = _addim(addim[i], units[i])
if unit is not None:
dat.setUnits(unit)
if scaling is None and value is None:
value = dat
dat = None
else:
if value is None: value='$VALUE'
if scaling is None:
if isinstance(value, _ver.basestring):
value = _mds.Data.compile(value)
else:
if not isinstance(value, _ver.basestring):
value = value.decompile()
value = _mds.Data.compile(value.replace('$VALUE',' polyval($VALUE,'+_mds.makeArray(scaling).decompile()+') '))
sig = _mds.Signal(value, dat, dim, *addim)
if help:
sig.setHelp(help)
return sig
def writedata(data, dims, nodepath, expt, shot):
""" data: list of images """
""" dims: array of double seconds based on T1 """
tree = _mds.Tree(expt, shot)
node = tree.getNode(nodepath)
node.deleteData()
for i in range(len(data)):
dim = _mds.Float64Array(dims[i])
dim.setUnits('s')
node.makeSegment(dims[i], dims[i], dim, _mds.makeArray(data[i]), -1)
def writedata(nodename, data, dims, shot=0):
""" data: list of images """
""" dims: array of double seconds based on T1 """
w7x = _mds.Tree('W7X', shot)
triax = w7x.getNode('.QSQ.HARDWARE.TRIAX')
node = triax.getNode(nodename)
node.deleteData()
for i in range(len(data)):
dim = _mds.Float64Array(dims[i])
dim.setUnits('s')
node.makeSegment(dims[i], dims[i], dim, _mds.makeArray(data[i]), -1)
def write_MDSplus(put_data, t):
node = t.getNode('.log.machine:timing')
data = MDSplus.makeData(put_data)
node.putData(data)
#create pulse and perform init phase
print '='*5,'Current_shot: %d, executing shot: %d'%(cur_shot, executing_shot),'='*5
dispatch_cmd('set tree %s' % tree, destination)
dispatch_cmd('create pulse %d' % executing_shot, destination)
time.sleep(3)
#print 'press enter.......'
#raw_input()
#maybe remove this???!
if tree=='h1data':
tmp_tree = MDSplus.Tree('h1data', executing_shot)
#print 'opened tree'
pulse_created_node = tmp_tree.getNode('.log.statistics:init_done')
#print 'told tree it has been created'
pulse_created_node.putData(MDSplus.makeData('1'))
#print 'told tree it has been created'
dispatch_cmd('dispatch /build', destination)
tmp_time = time.time()
print "sending event"
# only send EXECUTING_SHOT as CURRENT_SHOT is EXECUTING_SHOT -1
MDSplus.Event.setevent("EXECUTING_SHOT",executing_shot)
dispatch_cmd('dispatch /phase INIT', destination)
print '--> time to perform INIT %.2fs'%(time.time() - tmp_time)
#SH 20May2013 - testing abort phase
# print 'Init command has finished for some reason....'
# print 'press any key to redo the INIT phase'
# raw_input()
def storeftp(self, arg):
path = self.local_path
tree = self.local_tree
shot = self.tree.shot
CPCIDataDir = os.getenv('CPCI_DATA_DIR')
if not CPCIDataDir:
raise 'CPCI_DATA_DIR environment variable must be defined'
dataDir="%s/%s/%s/%s"%(CPCIDataDir, tree, shot, path,)
try :
settingsf = open("%s/settings.xml"%(dataDir,), "r")
except :
raise Exception,"Could not open Settings file %s/settings.xml"%(dataDir,)
try :
settings = load(settingsf)
except:
settingsf.close()
raise Exception, "Could not parse XML settings"
settingsf.close()
if self.debugging() :
print "xml is loaded\n"
status = []
cmds = self.status_cmds.record
for cmd in cmds:
cmd = cmd.strip()
if self.debugging():
print "about to append answer for /%s/\n" % (cmd,)
print " which is /%s/\n" %(settings[cmd],)
status.append(settings[cmd])
if self.debugging():
print "%s returned %s\n" % (cmd, settings[cmd],)
if self.debugging():
print "about to write board_status signal"
self.board_status.record = MDSplus.Signal(cmds, None, status)
numSampsStr = settings['getNumSamples']
preTrig = self.getPreTrig(numSampsStr)
postTrig = self.getPostTrig(numSampsStr)
if self.debugging():
print "got preTrig %d and postTrig %d\n" % (preTrig, postTrig,)
vins = MDSplus.makeArray(numpy.array(settings['get.vin'].split(',')).astype('float'))
if self.debugging:
print "got the vins "
print vins
self.ranges.record = MDSplus.makeArray(numpy.array(settings['get.vin'].split(',')).astype('float'))
chanMask = settings['getChannelMask'].split('=')[-1]
if self.debugging():
print "chan_mask = %s\n" % (chanMask,)
clock_src=self.clock_src.record.getOriginalPartName().getString()[1:]
if self.debugging():
print "clock_src = %s\n" % (clock_src,)
if clock_src == 'INT_CLOCK' :
intClock = float(settings['getInternalClock'].split()[1])
delta=1./float(intClock)
self.clock.record = MDSplus.Range(None, None, delta)
else:
self.clock.record = self.clock_src
clock = self.clock.record
#
# now store each channel
#
for chan in range(16):
if self.debugging():
print "working on channel %d" % chan
chan_node = self.__getattr__('input_%2.2d' % (chan+1,))
if chan_node.on :
if self.debugging():
print "it is on so ..."
if chanMask[chan:chan+1] == '1' :
try:
start = max(int(self.__getattr__('input_%2.2d_startidx'%(chan+1,))),-preTrig)
except:
start = -preTrig
try:
end = min(int(self.__getattr__('input_%2.2d_endidx'%(chan+1,))),postTrig-1)
except:
end = postTrig-1
try:
inc = max(int(self.__getattr__('input_%2.2d_inc'%(chan+1,))),1)
except:
inc = 1
#
# could do the coeffs
#
chanFileName="%s/%2.2d"%(dataDir, chan+1,)
if self.debugging():
print "about to readRawData(%s, preTrig=%d, start=%d, end=%d, inc=%d)" % (chanFileName, preTrig, start, end, inc)
buf = self.readRawData(chanFileName, preTrig, start, end, inc)
if inc == 1:
dim = MDSplus.Dimension(MDSplus.Window(start, end, self.trig_src ), clock)
else:
dim = MDSplus.Data.compile('Map($,$)', MDSplus.Dimension(MDSplus.Window(start/inc, end/inc, self.trig_src), clock), MDSplus.Range(start, end, inc))
dat = MDSplus.Data.compile(
'_v0=$, _v1=$, build_signal(build_with_units(( _v0+ (_v1-_v0)*($value - -32768)/(32767 - -32768 )), "V") ,build_with_units($,"Counts"),$)',
vins[chan*2], vins[chan*2+1], buf,dim)
exec('c=self.input_'+'%02d'%(chan+1,)+'.record=dat')
return 1