def archive_program(node, time=None):
""" use time if tree is archive """
""" else use TIME node """
print('archive_program')
try:
from archive import base, interface
from MDSplus import TreeNode, Tree
if not isinstance(node, (TreeNode)):
node = Tree('archive', -1).getNode(node)
""" use _time variable if Tree is ARCHIVE """
if node.tree.shot == -1:
try:
time = base.TimeInterval(time)
except:
time = base.TimeInterval([-1800., 0, 0])
else:
time = base.TimeInterval(node.getNode('\TIME').data())
prog = interface.get_program(time)[-1]
return prog[node.node_name.lower()]
except:
""" generate dummy signal with error message as help text """
import getpass, sys
user = getpass.getuser()
e = sys.exc_info()
help = user + ': ' + str(e[1]) + ', %d' % e[2].tb_lineno
print(help)
return help
def dclInterface(self):
Tree('pytree',-1,'ReadOnly').createPulse(self.shot)
self.assertEqual(dcl('help set verify',1,1,0)[1],None)
self.assertEqual(tcl('help set tree',1,1,0)[1],None)
self.assertEqual(ccl('help set xandq',1,1,0)[1],None)
self.assertEqual(cts('help addcrate',1,1,0)[1],None)
""" tcl commands """
self._doTCLTest('type test','test\n')
self._doTCLTest('close/all')
self._doTCLTest('show db','\n')
self._doTCLTest('set tree pytree/shot=%d'%(self.shot,))
self._doTCLTest('show db','000 PYTREE shot: %d [\\PYTREE::TOP] \n\n'%self.shot)
self._doTCLTest('edit PYTREE/shot=%d'%(self.shot,))
self._doTCLTest('add node TCL_NUM/usage=numeric')
self._doTCLTest('add node TCL_PY_DEV/model=TESTDEVICE')
self._doTCLTest('do TESTDEVICE:TASK_TEST')
self._doExceptionTest('do TESTDEVICE:TASK_ERROR',Exc.DevUNKOWN_STATE)
if not sys.platform.startswith('win'): # Windows does not support timeout yet
self._doExceptionTest('do TESTDEVICE:TASK_TIMEOUT',Exc.TdiTIMEOUT)
self._doExceptionTest('close',Exc.TreeWRITEFIRST)
self._doTCLTest('write')
self._doTCLTest('close')
self._doTCLTest('show db','\n')
""" context """
self._doTCLTest('set tree pytree')
pytree = Tree()
self.assertEqual(str(pytree),'Tree("PYTREE",-1,"Normal")')
self._doTCLTest('close pytree')
self.assertEqual(str(pytree),'Tree("PYTREE",-1,"Closed")')
""" tcl exceptions """
self._doExceptionTest('close',Exc.TreeNOT_OPEN)
self._doExceptionTest('dispatch/command/server=xXxXxXx type test',Exc.ServerPATH_DOWN)
self._doExceptionTest('dispatch/command/server type test',Exc.MdsdclIVVERB)
def test():
pytree = Tree('pytree', self.shot)
testing = Tree('testing', -1)
for node in testing.getNodeWild(".compression:*"):
pytree.SIG_CMPRS.record = node.record
self.assertTrue((pytree.SIG_CMPRS.record == node.record).all(),
msg="Error writing compressed signal%s" % node)
def archive_program(node, time=None):
""" use time if tree is archive """
""" else use TIME node """
print('archive_program')
try:
from archive import base, interface
from MDSplus import TreeNode, Tree
if not isinstance(node, (TreeNode)):
node = Tree('archive',-1).getNode(node)
""" use _time variable if Tree is ARCHIVE """
if node.tree.shot == -1:
try: time = base.TimeInterval(time)
except: time = base.TimeInterval([-1800.,0,0])
else:
time = base.TimeInterval(node.getNode('\TIME').data())
prog = interface.get_program(time)[-1]
return prog[node.node_name.lower()]
except:
""" generate dummy signal with error message as help text """
import getpass,sys
user = getpass.getuser()
e = sys.exc_info()
help = user+': '+str(e[1])+', %d' % e[2].tb_lineno
print(help)
return help
def init(self):
eventStr = "SETUP " + str(self.id.data()) + " " + Tree.getTree().name
eventStr = eventStr + " " + str(Tree.getTree().shot)
try:
eventStr = eventStr + " " + str(self.frequency.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot read frequency')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.trig_source.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read trigger source')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.sampl_start.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read Sampling start')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.sampl_end.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read Sampling end')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.offset_start.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read Offset start')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.offset_end.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read Offset end')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.duration.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot read Duration')
raise mdsExceptions.TclFAILED_ESSENTIAL
eventStr = eventStr + " " + str(self.params.getNid())
eventStr = eventStr + " " + str(self.wave_params.getNid())
eventStr = eventStr + " " + str(self.input_cal.getNid())
eventStr = eventStr + " " + str(self.output_cal.getNid())
try:
eventStr = eventStr + " " + self.control.data()
except:
Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot read Control')
raise mdsExceptions.TclFAILED_ESSENTIAL
eventStr = eventStr + " " + str(self.signals_adc_in.getNid())
eventStr = eventStr + " " + str(self.signals_dac_out.getNid())
eventStr = eventStr + " " + str(self.signals_user.getNid())
print(eventStr)
Event.setevent(self.getEventName(), eventStr)
sleep(3)
return
def test():
from MDSplus import Tree, Opaque
with Tree(self.tree, self.shot, 'NEW') as ptree:
ptree.addNode('JPGS')
ptree.addNode('JPG')
ptree.write()
ptree = Tree(self.tree, self.shot)
node = ptree.JPG
root = os.path.dirname(os.path.realpath(__file__))
node.record = Opaque.fromFile(root + '/images/mdsplus_logo.jpg')
opq = node.record
try:
opq.image
except ImportError as e:
print(e) # Image module not found
node = ptree.JPGS
node.makeSegment(
None, None, None,
Opaque.fromFile(root + '/images/mdsplus_logo.jpg'))
node.makeSegment(None, None, None,
Opaque.fromFile(root + '/images/test-mpeg.mpg'))
node.makeSegment(None, None, None,
Opaque.fromFile(root + '/images/test-mpeg.gif'))
self.assertEqual(len(node.record), 3)
lens = (54851, 706564, 77013)
for i in range(3):
seg = node.getSegment(i)
self.assertEqual(len(seg.value.value.data()), lens[i])
def test():
from MDSplus import Tree, Int32, Int64, Dimension, Range, Window, DIVIDE, ADD, MULTIPLY
from numpy import arange, ones, int16, int64
slp = 3.3
off = 1.1
trg = -1000000
clk = 1000000
with Tree(self.tree, self.shot, 'NEW') as ptree:
sig = ptree.addNode('SIG').record = ADD(
MULTIPLY(ptree.addNode('RAW'), ptree.addNode('SLP')),
ptree.addNode('OFF'))
ptree.addNode('TRG').record = Int64(trg)
ptree.addNode('CLK').record = Int32(clk)
ptree.write()
ptree = Tree(self.tree, self.shot)
trig = ptree.TRG
raw = ptree.RAW
sig = ptree.SIG
dt = DIVIDE(Int64(1e9), ptree.CLK)
rng = Range(None, None, dt)
wnd = Window(None, None, trig)
ptree.SLP.record = slp
ptree.OFF.record = off
length, seglen = 100, 10
dat = ones(seglen, dtype=int16)
for i0 in range(0, length, seglen):
i1 = i0 + seglen - 1
wnd[0], wnd[1] = Int64(i0), Int64(i1)
dim = Dimension(wnd, rng)
d0 = Int64(i0 * dt + trig)
d1 = Int64(i1 * dt + trig)
self.assertEqual(dim.data()[0], d0.data())
self.assertEqual(dim.data()[-1], d1.data())
raw.makeSegment(d0, d1, dim, dat)
self.assertEqual(
str(raw.getSegment(0)),
"Build_Signal(Word([1,1,1,1,1,1,1,1,1,1]), *, Build_Dim(Build_Window(0Q, 9Q, TRG), * : * : 1000000000Q / CLK))"
)
self.assertEqual(str(sig.record), "RAW * SLP + OFF")
self.assertTrue(sig.dim_of().tolist(),
(arange(0, length, dtype=int64) * int(1e9 / clk) +
trg).tolist())
self.assertTrue(
(abs(sig.data() -
(ones(length, dtype=int16) * slp + off)) < 1e-5).all(),
"Stored data does not match expected array")
# ptree.close()
# ptree.compressDatafile() # this will break the functionality of updateSegment
# ptree.open()
trig.record = 0
for i in range(int(length / seglen)):
dim = raw.getSegmentDim(i)
raw.updateSegment(dim.data()[0], dim.data()[-1], dim, i)
self.assertEqual(
str(raw.getSegment(0)),
"Build_Signal(Word([1,1,1,1,1,1,1,1,1,1]), *, Build_Dim(Build_Window(0Q, 9Q, TRG), * : * : 1000000000Q / CLK))"
)
self.assertTrue(sig.dim_of().tolist(),
(arange(0, length, dtype=int64) *
int(1e9 / clk)).tolist())
def extAttr(self):
with Tree('pytree',self.shot+0,'new') as pytree:
if pytree.shot != self.shot+0:
raise Exception("Shot number changed! tree.shot=%d, thread.shot=%d" % (pytree.shot, self.shot+0))
pytree.default.addNode('pytreesub','subtree').include_in_pulse=True
pytree.write()
self.assertEqual(pytree.versions_in_model,False)
self.assertEqual(pytree.versions_in_pulse,False)
pytree.versions_in_model = True
self.assertEqual(pytree.versions_in_model,True)
self.assertEqual(pytree.versions_in_pulse,False)
pytree.versions_in_pulse = 1
self.assertEqual(pytree.versions_in_model,True)
self.assertEqual(pytree.versions_in_pulse,True)
with Tree('pytreesub',self.shot+0,'new') as pytreesub:
if pytreesub.shot != self.shot+0:
raise Exception("Shot number changed! tree.shot=%d, thread.shot=%d" % (pytreesub.shot, self.shot+0))
node=pytreesub.addNode('node','signal')
node.setExtendedAttribute('ATT1',100)
node.setExtendedAttribute('ATT2',Range(1,200))
node.setExtendedAttribute('ATT3','this is ip')
node.setExtendedAttribute('ATT3','this is plasma current')
pytreesub.write()
pytree.readonly()
node = pytree.getNode(".PYTREESUB:NODE")
self.assertEqual(str(node.getExtendedAttribute('ATT1')),'100')
self.assertEqual(str(node.getExtendedAttribute('ATT2')),'1 : 200 : *')
self.assertEqual(str(node.getExtendedAttribute('ATT3')),'this is plasma current')
exattr = node.getExtendedAttributes()
self.assertEqual(exattr['ATT1'],100)
self.assertEqual(str(exattr['ATT2']),'1 : 200 : *')
self.assertEqual(exattr['ATT3'],'this is plasma current')
def attr(self):
shot = self.shot + 0
with Tree('pytree', shot, 'new') as pytree:
self.assertEqual(pytree.shot, shot)
pytree.default.addNode('pytreesub',
'subtree').include_in_pulse = True
pytree.write()
self.assertEqual(pytree.versions_in_model, False)
self.assertEqual(pytree.versions_in_pulse, False)
pytree.versions_in_model = True
self.assertEqual(pytree.versions_in_model, True)
self.assertEqual(pytree.versions_in_pulse, False)
pytree.versions_in_pulse = 1
self.assertEqual(pytree.versions_in_model, True)
self.assertEqual(pytree.versions_in_pulse, True)
with Tree('pytreesub', shot, 'new') as pytreesub:
self.assertEqual(pytreesub.shot, shot)
node = pytreesub.addNode('node', 'signal')
node.setExtendedAttribute('ATT1', 100)
node.setExtendedAttribute('ATT2', Range(1, 200))
node.setExtendedAttribute('ATT3', 'this is ip')
node.setExtendedAttribute('ATT3', att3)
pytreesub.write()
pytree.readonly()
node = pytree.getNode(".PYTREESUB:NODE")
self.assertEqual(str(node.getExtendedAttribute('ATT1')), '100')
self.assertEqual(str(node.getExtendedAttribute('ATT2')), att2)
self.assertEqual(str(node.getExtendedAttribute('ATT3')), att3)
exattr = node.getExtendedAttributes()
self.assertEqual(exattr['ATT1'], 100)
self.assertEqual(str(exattr['ATT2']), att2)
self.assertEqual(exattr['ATT3'], att3)
def master(self):
from MDSplus import Tree, TreeFILE_NOT_FOUND,TreeFOPENR
path = self.master_path.record
expt = str(path).split('::',2)[0].strip('\\')
try:
return Tree(expt,self.tree.shot,'ReadOnly').getNode(path)
except (TreeFOPENR,TreeFILE_NOT_FOUND):
return Tree(expt,-1,'ReadOnly').getNode(path)
def test():
with Tree('pytree', self.shot, 'new') as pytree:
if pytree.shot != self.shot:
raise Exception(
"Shot number changed! tree.shot=%d, thread.shot=%d" %
(pytree.shot, self.shot))
pytree.default.addNode('pytreesub',
'subtree').include_in_pulse = True
for i in range(10):
node = pytree.addNode('val%02d' % (i, ), 'numeric')
node.record = i
node = pytree.top.addNode('sig%02d' % (i, ), 'signal')
node.record = Signal(i, None, i)
node = pytree.top.addNode('child%02d' % (i, ), 'structure')
node.addNode('text', 'text')
node.addNode('child', 'structure')
node = pytree.addNode('SIG_CMPRS', 'signal')
node.compress_on_put = True
Device.PyDevice('TestDevice').Add(pytree, 'TESTDEVICE')
Device.PyDevice('CYGNET4K').Add(pytree, 'CYGNET4K').on = False
pytree.write()
with Tree('pytreesub', self.shot, 'new') as pytreesub:
if pytreesub.shot != self.shot:
raise Exception(
"Shot number changed! tree.shot=%d, thread.shot=%d" %
(pytreesub.shot, self.shot))
pytreesub_top = pytreesub.default
node = pytreesub_top.addNode('.rog', 'structure')
for i in range(10):
node = node.addNode('.child', 'structure')
node = node.addNode('rogowski', 'structure')
node.tag = 'MAG_ROGOWSKI'
node = node.addNode('signals', 'structure')
node = node.addNode('rog_fg', 'signal')
node.record = Signal(Range(1., 1000.), None,
Range(1., 100., .1))
node = pytreesub_top.addNode('btor', 'signal')
node.tag = 'BTOR'
node.compress_on_put = True
node.record = Signal(Range(2., 2000., 2.), None,
Range(1., 1000.))
ip = pytreesub_top.addNode('ip', 'signal')
rec = pytreesub.tdiCompile(
"Build_Signal(Build_With_Units(\\MAG_ROGOWSKI.SIGNALS:ROG_FG + 2100. * \\BTOR, 'ampere'), *, DIM_OF(\\BTOR))"
)
ip.record = rec
ip.tag = 'MAG_PLASMA_CURRENT'
ip.tag = 'MAGNETICS_PLASMA_CURRENT'
ip.tag = 'MAG_IP'
ip.tag = 'MAGNETICS_IP'
ip.tag = 'IP'
for i in range(10):
node = pytreesub_top.addNode('child%02d' % (i, ),
'structure')
node.addDevice('dt200_%02d' % (i, ), 'dt200').on = False
pytreesub.write()
def __init__(self, dbname, shot, ):
self.tree = Tree(dbname, shot)
# 节点列表 {'AI':[...], 'FBC':[...]}
subtrees = ['AI', 'FBC',]
self.channel_dic = {}
for subtree in subtrees:
nodes_array = self.tree.getNode(subtree).getDescendants()
nodes_name = [node.getNodeName() for node in nodes_array]
self.channel_dic[subtree] = nodes_name
def run(self):
"""Run test1.test() function"""
Tree.usePrivateCtx()
stream = StringIO()
try:
self.result = TextTestRunner(stream=stream,verbosity=2).run(self.test)
finally:
stream.seek(0)
self.stream = stream.read()
stream.close()
def getCompression(self):
with Tree('pytree',self.shot+10,'new') as pytree:
node = pytree.addNode('SIG_CMPRS', 'signal')
node.compress_on_put = True
pytree.write()
pytree.normal()
testing = Tree('testing', -1)
for node in testing.getNodeWild(".compression:*"):
pytree.SIG_CMPRS.record=node.record
self.assertTrue((pytree.SIG_CMPRS.record == node.record).all(),
msg="Error writing compressed signal%s"%node)
def test():
pytree = Tree('pytree', self.shot, 'ReadOnly')
ip = pytree.getNode('\\ip')
self.assertEqual(str(ip), '\\PYTREESUB::IP')
self.assertEqual(ip.nid, pytree._IP.nid)
self.assertEqual(ip.nid, pytree.__PYTREESUB.IP.nid)
self.assertEqual(ip.nid, pytree.__PYTREESUB__IP.nid)
self.assertEqual(pytree.TESTDEVICE.__class__,
Device.PyDevice('TESTDEVICE'))
self.assertEqual(pytree.CYGNET4K.__class__,
Device.PyDevice('CYGNET4K'))
def test():
pytree = Tree('pytree', self.shot, 'ReadOnly')
ip = pytree.getNode('\\ip')
pytree.setDefault(ip)
self.assertEqual(
str(ip.record),
'Build_Signal(Build_With_Units(\\MAG_ROGOWSKI.SIGNALS:ROG_FG + 2100. * \\BTOR, "ampere"), *, DIM_OF(\\BTOR))'
)
self.assertEqual(str(ip.record), str(ip.getData()))
self.assertEqual(ip.segmented, ip.isSegmented())
self.assertEqual(ip.versions, ip.containsVersions())
self.assertEqual(ip.getNumSegments(), 0)
self.assertEqual(ip.getSegment(0), None)
def openTree(self,tree,shot):
Tree.usePrivateCtx()
try:
shot=int(shot)
except Exception:
raise Exception("Invalid shot specified, must be an integer value: %s<br /><br />Error: %s" % (shot,sys.exc_info()))
try:
t=Tree(tree,shot)
self.tree=t.tree
self.shot=str(t.shot)
self.treeObj=t
except Exception:
raise Exception("Error opening tree named %s for shot %d<br /><br />Error: %s" % (tree,shot,sys.exc_info()))
def archive_log(node, time=None, cache=None):
""" use time if tree is archive """
""" else use TIME node """
print('archive_log')
try:
from archive import base, interface
from MDSplus import TreeNode, Tree
if not isinstance(node, (TreeNode)):
node = Tree('archive',-1).getNode(node)
""" use _time variable if Tree is ARCHIVE """
try:
node.getNode('$CFGLOG')
url = base.Path(node.getNode('$URL').data()).url_cfglog()
except:
try:
node.getNode('$PARLOG')
url = base.Path(node.getNode('$URL').data()).url_parlog()
except:
raise Exception('could not specify log type. No Member named $CFGLOG or $PARLOG')
if node.tree.shot == -1:
try: time = base.TimeInterval(time)
except: time = base.TimeInterval(['now'])
else:
time = base.TimeInterval(node.getNode('\TIME').data())
""" request signal """
return str(interface._get_json(url, time=time).read())
except:
""" generate error message"""
import getpass,sys
user = getpass.getuser()
e = sys.exc_info()
help = user+': '+str(e[1])+', %d' % e[2].tb_lineno
print(help)
return help
def getNode(self):
with Tree('pytree',self.shot+3,'new') as pytree:
pytree.addNode('pytreesub','subtree').include_in_pulse=True
pytree.write()
with Tree('pytreesub',self.shot+3,'new') as pytreesub:
ip=pytreesub.addNode('ip','signal')
ip.tag='IP'
pytreesub.write()
pytree=Tree('pytree',self.shot+3,'ReadOnly')
ip = pytree.getNode('\\ip')
self.assertEqual(str(ip),'\\PYTREESUB::IP')
self.assertEqual(ip.nid,pytree._IP.nid)
self.assertEqual(ip.nid,pytree.__PYTREESUB.IP.nid)
self.assertEqual(ip.nid,pytree.__PYTREESUB__IP.nid)
def setDefault(self):
with Tree('pytree',self.shot+5,'new') as pytree:
pytree.default.addNode('pytreesub','subtree').include_in_pulse=True
pytree.write()
with Tree('pytreesub',self.shot+5,'new') as pytreesub:
pytreesub.default.addNode('mynode','numeric').addTag("mytag")
pytreesub.write()
pytree.readonly()
pytree2 = Tree('pytree',self.shot+5,"ReadOnly")
pytree.setDefault(pytree._MYTAG)
self.assertEqual(str(pytree.getDefault()),'\\PYTREESUB::MYTAG')
self.assertEqual(str(pytree2.getDefault()),'\\PYTREE::TOP')
pytree.getNode("\\PYTREESUB::TOP").setDefault()
self.assertEqual(str(pytree.getDefault()),'\\PYTREESUB::TOP')
def segments(self):
pytree = Tree('pytree', self.shot)
signal = pytree.SIG01
signal.record = None
signal.compress_on_put = False
for i in range(2000):
signal.putRow(100, Range(1, 1000).data(), DateToQuad("now"))
pytree.createPulse(self.shot + 2)
signal.compress_segments = True
pytree3 = Tree('pytree', self.shot + 2)
pytree3.compressDatafile()
self.assertEqual((signal.record == pytree3.SIG01.record).all(), True)
signal.deleteData()
# beginning a block set next_row to 0
signal.beginTimestampedSegment(Int32Array([0, 7]))
self.assertEqual(str(signal.record), "Build_Signal([], *, [])")
self.assertEqual(str(signal.getSegment(0)), "Build_Signal([], *, [])")
# beginning adding row increments next_row to 1
signal.putRow(1, Int32Array([1]), -1)
self.assertEqual(str(signal.record), "Build_Signal([1], *, [-1Q])")
self.assertEqual(str(signal.getSegment(0)),
"Build_Signal([1], *, [-1Q])")
# beginning a new block set next_row back to 0 of the new block
# the previous block is assumed to be full as the tailing zero could be valid data
signal.beginTimestampedSegment(Int32Array([0]))
self.assertEqual(str(signal.record),
"Build_Signal([1,7], *, [-1Q,0Q])")
self.assertEqual(str(signal.getSegment(0)),
"Build_Signal([1,7], *, [-1Q,0Q])")
def getCurrentShot(self):
""" 获取当前炮号 """
try:
shot_num = self.tree.getCurrent()
new_tree = Tree(self.dbname, shot_num)
shot_num = shot_num if new_tree.getNode(
'FBC:DUPS1').getLength() else shot_num - 1
except mdsExceptions.TreeNNF:
# MDSplus.mdsExceptions.TreeNNF: %TREE-W-NNF, Node Not Found
shot_num = shot_num if new_tree.getNode(
'FBC:IP').getLength() else shot_num - 1
except mdsExceptions.TreeNOCURRENT:
# MDSplus.mdsExceptions.TreeNOCURRENT: %TREE-E-NOCURRENT, No current shot number set for this tree.
shot_num = None
return shot_num
def treeCtx(self):
from gc import collect
from time import sleep
def check(n):
self.assertEqual(n, len(list(tree._TreeCtx.ctxs.items())[0][1]))
self.assertEqual(tree._TreeCtx.ctxs,
{}) # neither tcl nor tdi has been called yet
tcl('edit pytree/shot=%d/new' % self.shot)
check(1)
Data.execute('$EXPT')
check(1)
t = Tree()
check(2)
Data.execute('tcl("dir", _out)')
check(2)
del (t)
collect(2)
sleep(.1)
check(1)
Data.execute('_out')
check(1)
t = Tree('pytree', self.shot + 1, 'NEW')
self.assertEqual(len(tree._TreeCtx.ctxs[tree._TreeCtx.local.tctx.ctx]),
1)
self.assertEqual(len(tree._TreeCtx.ctxs[t.ctx.value]), 1)
Data.execute('tcl("close")')
self.assertEqual(len(tree._TreeCtx.ctxs[tree._TreeCtx.local.tctx.ctx]),
1)
self.assertEqual(len(tree._TreeCtx.ctxs[t.ctx.value]), 1)
self.assertEqual(str(t),
'Tree("PYTREE",%d,"Edit")' % (self.shot + 1, ))
self.assertEqual(str(Data.execute('tcl("show db", _out);_out')), "\n")
del (t)
collect(2)
sleep(.01)
check(1)
# tcl/tdi context remains until end of session
t = Tree('pytree', self.shot + 1, 'NEW')
self.assertEqual(len(tree._TreeCtx.ctxs[tree._TreeCtx.local.tctx.ctx]),
1)
self.assertEqual(len(tree._TreeCtx.ctxs[t.ctx.value]), 1)
del (t)
collect(2)
sleep(.01)
check(1)
self.cleanup()
def scaled(self):
with Tree(self.tree, self.shot + 7, 'NEW') as ptree:
node = ptree.addNode('S')
ptree.write()
ptree.normal()
srt, end, dt = -1000, 1000, 1000
d = Int64Array(range(srt, end + 1, dt))
v = Int16Array(range(srt, end + 1, dt))
node.makeSegment(srt, end, d, v)
self.assertEqual(True, (node.getSegment(0).data() == v.data()).all())
node.setSegmentScale(Int64(2))
self.assertEqual(node.getSegmentScale().decompile(), "$VALUE * 2Q")
self.assertEqual(
ptree.tdiExecute("GetSegmentScale(S)").decompile(), "$VALUE * 2Q")
self.assertEqual(True, (node.record.data() == v.data() * 2).all())
node.setSegmentScale(Int16Array([1, 2]))
self.assertEqual(True, (node.record.data() == v.data() * 2 + 1).all())
self.assertEqual(True, (node.getSegment(0) == v * 2 + 1).all())
self.assertEqual(
ptree.tdiExecute("GetSegment(S,0)").decompile(),
"Build_Signal($VALUE * 2W + 1W, Word([-1000,0,1000]), [-1000Q,0Q,1000Q])"
)
ptree.tdiExecute("SetSegmentScale(S,as_is($VALUE+1D0))")
self.assertEqual(
ptree.tdiExecute("S").decompile(),
"Build_Signal($VALUE + 1D0, Word([-1000,0,1000]), [-1000Q,0Q,1000Q])"
)
def plotdata(path='\\ARCHIVESB::DMD10195:CH1',
treename='sandbox',
shot=5,
server=None):
from MDSplus import Connection
from pylab import plot, title, xlabel, ylabel
if server is not None:
Con = Connection(server)
Con.openTree(treename, shot)
name = Con.get('{}:$NAME'.format(path))
data = Con.get('DATA({})'.format(path))
time = Con.get('DIM_OF({})'.format(path))
unit = Con.get('UNITS_OF({})'.format(path))
else:
with Tree(treename, shot) as tree:
Node = tree.getNode(path)
Data = Node.getData()
name = Node.getNode('$NAME').data()
data = Data.data()
time = Data.dim_of().data()
unit = Data.getUnits()
plot(time, data)
xlabel('time (s)')
ylabel(unit)
title(name)
def DimensionlessSegments(self):
from MDSplus import Tree,Int32Array,numpy,TreeBUFFEROVF
with Tree(self.tree,self.shot+8,'NEW') as ptree:
ptree.addNode('S')
ptree.write()
ptree.normal()
node = ptree.S
len = 10
seg0 = Int32Array(numpy.array(range(len)))
for i in range(10):
seg = seg0 + i*len
start, end = seg[0],seg[len-1]
node.makeSegment(start, end, None, seg)
seg = seg0 + 10*len
start, end = seg[0],seg[len-1]
node.beginSegment(start, end, None, seg)
node.putSegment(seg[0:1])
self.assertEqual(node.record.data()[-5:].tolist(),[96,97,98,99,100])
node.putSegment(seg[1:2])
self.assertEqual(node.record.data()[-5:].tolist(),[97,98,99,100,101])
self.assertEqual(node.getSegment(0).data().tolist(),seg0.tolist())
self.assertEqual(node.record.data()[:10].tolist(),seg0.tolist())
ptree.compressDatafile()
ptree.normal()
self.assertEqual(node.record.data()[-5:].tolist(),[97,98,99,100,101])
try: node.putSegment(seg[2:3]) # compress finalizes last segment, putSegment cannot put
except TreeBUFFEROVF: pass
else: self.assertEqual(None,TreeBUFFEROVF)
ptree.setTimeContext(17,21,None) # interval contained in segment 1 and 2
self.assertEqual(node.record.data().tolist(),[17,18,19,20,21])
def opaque(self):
with Tree(self.tree, self.shot + 3, 'NEW') as ptree:
ptree.addNode('JPGS')
ptree.addNode('JPG')
ptree.write()
ptree.normal()
node = ptree.JPG
root = os.path.dirname(os.path.realpath(__file__))
node.record = Opaque.fromFile(root + '/images/test.jpg')
opq = node.record
try:
opq.image
except ImportError as e:
print(e) # Image module not found
node = ptree.JPGS
node.makeSegment(None, None, None,
Opaque.fromFile(root + '/images/test.jpg'))
node.makeSegment(None, None, None,
Opaque.fromFile(root + '/images/test.mpg'))
node.makeSegment(None, None, None,
Opaque.fromFile(root + '/images/test.gif'))
self.assertEqual(len(node.record), 3)
lens = (5977, 10240, 4292)
for i in range(3):
seg = node.getSegment(i)
self.assertEqual(len(seg.value.value.data()), lens[i])
def dispatcher(self):
shot = self.shot+1
with Tree(self.tree,shot,'new') as pytree:
Device.PyDevice('TestDevice').Add(pytree,'TESTDEVICE_I')
Device.PyDevice('TestDevice').Add(pytree,'TESTDEVICE_S',add_source=True)
pytree.write()
monitor,monitor_port = self._setup_mdsip('ACTION_MONITOR','MONITOR_PORT',7010+self.index,False)
monitor_opt = "/monitor=%s"%monitor if monitor_port>0 else ""
server ,server_port = self._setup_mdsip('ACTION_SERVER', 'ACTION_PORT',7000+self.index,True)
pytree.normal()
pytree.TESTDEVICE_I.ACTIONSERVER.no_write_shot = False
pytree.TESTDEVICE_I.ACTIONSERVER.record = server
pytree.TESTDEVICE_S.ACTIONSERVER.no_write_shot = False
pytree.TESTDEVICE_S.ACTIONSERVER.record = server
""" using dispatcher """
mon,mon_log,svr,svr_log = (None,None,None,None)
try:
mon,mon_log = self._start_mdsip(monitor,monitor_port,'monitor')
svr,svr_log = self._start_mdsip(server ,server_port ,'dispatcher')
try:
if mon: self.assertEqual(mon.poll(),None)
if svr: self.assertEqual(svr.poll(),None)
#Connection(server).get("""py("MDSplus.Device.PyDevice('TestDevice')","None")""")
""" tcl dispatch """
self._testDispatchCommand(server,'type test')
self._doTCLTest('set tree pytree/shot=%d'%shot)
#if not self.in_valgrind:
# self._doTCLTest('dispatch TESTDEVICE_S:ACTIONSERVER:MANUAL')
# self._waitIdle(server,3)
#else:
# sys.stdout.write("VALGRIND: skipping 'dispatch TESTDEVICE_S:ACTIONSERVER:MANUAL'\n")
# sys.stdout.flush()
self._doTCLTest('dispatch/build%s'%monitor_opt)
self._doTCLTest('dispatch/phase%s INIT'%monitor_opt)
self._waitIdle(server,3)
self._doTCLTest('dispatch/phase%s PULSE'%monitor_opt)
self._waitIdle(server,3)
self._doTCLTest('dispatch/phase%s STORE'%monitor_opt)
self._waitIdle(server,3)
""" tcl exceptions """
self._doExceptionTest('dispatch/command/server=%s '%server,Exc.MdsdclIVVERB)
""" tcl check if still alive """
if mon: self.assertEqual(mon.poll(),None)
if svr: self.assertEqual(svr.poll(),None)
finally:
self._stop_mdsip((svr,server),(mon,monitor))
finally:
if svr_log: svr_log.close()
if mon_log: mon_log.close()
self._doTCLTest('close/all')
pytree.readonly()
#if not self.in_valgrind:
# self.assertTrue(pytree.TESTDEVICE_S.MANUAL_DONE.record<= pytree.TESTDEVICE_S.INIT1_DONE.record)
self.assertTrue(pytree.TESTDEVICE_I.INIT1_DONE.record <= pytree.TESTDEVICE_I.INIT2_DONE.record)
self.assertTrue(pytree.TESTDEVICE_S.INIT1_DONE.record <= pytree.TESTDEVICE_S.INIT2_DONE.record)
self.assertTrue(pytree.TESTDEVICE_I.INIT2_DONE.record <= pytree.TESTDEVICE_I.STORE_DONE.record)
self.assertTrue(pytree.TESTDEVICE_S.INIT2_DONE.record <= pytree.TESTDEVICE_S.STORE_DONE.record)
self.assertEqual(pytree.TESTDEVICE_I.CHANNEL.data().tolist(),[0,1,2,3,4,5,6,7,8,9])
self.assertEqual(pytree.TESTDEVICE_S.CHANNEL.data().tolist(),[0,1,2,3,4,5,6,7,8,9])
def data(self):
shot = self.shot + 7
with Tree('pytree', shot, 'new') as pytree:
pytree.default.addNode('pytreesub',
'subtree').include_in_pulse = True
pytree.write()
with Tree('pytreesub', shot, 'new') as pytreesub:
node = pytreesub.addNode('.rog', 'structure')
for i in range(10):
node = node.addNode('.child', 'structure')
node = node.addNode('rogowski', 'structure')
node.tag = 'MAG_ROGOWSKI'
node = node.addNode('signals', 'structure')
node = node.addNode('rog_fg', 'signal')
node.record = Signal(Range(1., 1000.), None, Range(1., 100., .1))
node = pytreesub.addNode('btor', 'signal')
node.tag = 'BTOR'
node.compress_on_put = True
node.record = Signal(Range(2., 2000., 2.), None, Range(1., 1000.))
ip = pytreesub.addNode('ip', 'signal')
ip.tag = "IP"
rec = pytreesub.tdiCompile(
"Build_Signal(Build_With_Units(\\MAG_ROGOWSKI.SIGNALS:ROG_FG + 2100. * \\BTOR, 'ampere'), *, DIM_OF(\\BTOR))"
)
ip.record = rec
pytreesub.versions_in_pulse = True
pytreesub.write()
pytree.readonly()
ip = pytree.getNode('\\IP')
pytree.setDefault(ip)
self.assertEqual(
str(ip.record),
'Build_Signal(Build_With_Units(\\MAG_ROGOWSKI.SIGNALS:ROG_FG + 2100. * \\BTOR, "ampere"), *, DIM_OF(\\BTOR))'
)
self.assertEqual(str(ip.record), str(ip.getData()))
self.assertEqual(ip.segmented, ip.isSegmented())
self.assertEqual(ip.versions, ip.containsVersions())
self.assertEqual(ip.versions, False)
self.assertEqual(ip.getNumSegments(), 0)
self.assertEqual(ip.getSegment(0), None)
pytree.normal()
ip.record = ADD(1, COMPILE("\\BTOR"))
self.assertEqual(ip.versions, True)
self.assertEqual(ip.record.decompile(), '1 + COMPILE("\\\\BTOR")')
self.assertEqual(ip.record.data().tolist(),
(pytree.getNode("\\BTOR").data() + 1).tolist())
def DevicesTests(self, package):
with Tree('devtree', -1, 'new') as t:
devices = __import__(package).__dict__
for model in sorted(devices.keys()):
cls = devices[model]
if isinstance(cls, type) and issubclass(cls, Device):
node, name = self.getNodeName(t, model)
cls.Add(node, name)
def test():
from MDSplus import Tree, DateToQuad, Range
with Tree('seg_tree', self.shot, 'NEW') as ptree:
ptree.addNode('S').compress_on_put = False
ptree.write()
ptree = Tree(self.tree, self.shot)
node = ptree.S
for i in range(200):
node.putRow(100, Range(1, 100).data(), DateToQuad("now"))
ptree.createPulse(self.shot + 1)
node.compress_segments = True
ptree1 = Tree(self.tree, self.shot + 1)
ptree1.compressDatafile()
self.assertEqual((node.record == ptree1.S.record).all(), True)
def CompressSegments(self):
from MDSplus import Tree,DateToQuad,ZERO,Int32,Int32Array,Int64Array,Range
with Tree(self.tree,self.shot+9,'NEW') as ptree:
node = ptree.addNode('S')
node.compress_on_put = False
ptree.write()
ptree.cleanDatafile()
ptree.normal()
te = DateToQuad("now")
sampperseg = 50
data = ZERO(Int32Array([sampperseg]),Int32(0))
numsegs = 128
for i in range(numsegs):
t0=te+1;te=t0+sampperseg-1
node.makeSegment(t0,te,Int64Array(range(t0,te+1)),data+Int32(i))
node.compress_segments=True
ptree.createPulse(self.shot+11)
Tree.compressDatafile(self.tree,self.shot+11)
ptree1 = Tree(self.tree,self.shot+11)
node1 = ptree1.S
self.assertEqual(True,(node.record==node1.record).all())
self.assertEqual(True,ptree.getDatafileSize()>ptree1.getDatafileSize())
for i in range(numsegs):
srt,end = node.getSegmentLimits(i)
dim = Range(srt,end)
node.updateSegment(srt,end,dim,i)
if i%16==0:
self.assertEqual(dim.decompile(),node.getSegmentDim(i).decompile())
ptree.compressDatafile()
ptree.readonly()
self.assertEqual(numsegs,node1.getNumSegments())
self.assertEqual(True,ptree.getDatafileSize()<ptree1.getDatafileSize())
for i in range(numsegs):
self.assertEqual(node.getSegmentDim(i).data().tolist(),node1.getSegmentDim(i).data().tolist())
def archive_image(node, time=None):
""" use time if tree is archive """
""" else use TIME node """
print('archive_image')
try:
from archive import base, interface
from MDSplus import TreeNode, Tree
if not isinstance(node, (TreeNode)):
node = Tree('archive',-1).getNode(node)
""" use _time variable if Tree is ARCHIVE """
if node.tree.shot == -1:
try: time = base.TimeInterval(time)
except: time = base.TimeInterval([-1800.,0,0])
else:
time = base.TimeInterval(node.getNode('\TIME').data())
url = base.Path(node.getNode('$URL').data()).url_datastream()
""" request signal """
signal = interface.read_pngs_url(url, time, 3)
""" generate help text (HELP, DESCRIPTION, $NAME) """
try: help = node.getNode('HELP').data()
except:
try: help = node.getNode('DESCRIPTION').data()
except: help = node.getNode('$NAME').data()
signal.setHelp(str(help))
return signal
except:
local = locals()
""" generate dummy signal with error message as help text """
import getpass,sys
e = sys.exc_info()
user = getpass.getuser()
help = user+': %s, %d' % (repr(e[1]), e[2].tb_lineno)
print(help)
print(local)
try:
from MDSplus import Signal
signal = Signal([6,66,666])
signal.setHelp(help.split('\n')[-1])
return(signal)
except:
return help
ERRORn
"""
def doScopepanel(self):
def getStringExp(self,name,response_headers):
if name in self.args:
try:
response_headers.append((name,str(Data.execute(self.args[name][-1]).data())))
except Exception,e:
response_headers.append((name,str(e)))
response_headers=list()
response_headers.append(('Cache-Control','no-store, no-cache, must-revalidate'))
response_headers.append(('Pragma','no-cache'))
if 'tree' in self.args:
Tree.usePrivateCtx()
try:
t=Tree(self.args['tree'][-1],int(self.args['shot'][-1].split(',')[0]))
except:
pass
for name in ('title','xlabel','ylabel','xmin','xmax','ymin','ymax'):
getStringExp(self,name,response_headers)
sig_idx=0
output=''
if 'tree' in self.args:
shots=self.args['shot'][-1].split(',')
for shot in shots:
y_idx=1
y_idx_s='%d' % (y_idx,)
def archive_signal(node, time=None, cache=None):
""" use time if tree is archive """
""" else use TIME node """
print('archive_signal')
try:
from archive import base, interface
from MDSplus import TreeNode, Tree, Data, mdsExceptions
if not isinstance(node, (TreeNode)):
node = Tree('archive',-1).getNode(node)
""" use _time variable if Tree is ARCHIVE """
if node.tree.shot == -1:
try: time = base.TimeInterval(time)
except: time = base.TimeInterval([-1800.,0,0])
else:
time = base.TimeInterval(node.getNode('\TIME').data())
"""handle arguments"""
kwargs = {}
if str(node.node_name)[0]=='$':
kwargs['scaled'] = str(node.node_name)[1:].lower()
node = node.getParent()
else:
try: kwargs['scaling'] = node.getNode('AIDEVSCALING').data()
except: pass
try:
kwargs['value'] = node.getNode('$VALUE').data()
except:
try:
gain = node.getNode('GAIN').data()
zero = node.getNode('ZEROOFFSET').data()
if gain!=1. or zero!=0.:
kwargs['value'] = Data.compile('$VALUE*$+$',(gain,zero))
except Exception as exc:
if not isinstance(exc,mdsExceptions.TreeNNF):
print(exc)
if cache is not None: kwargs['cache'] = cache
try: # load channels by datastream + index
kwargs['channel'] = node.getNode('$IDX').data()
url = node.getParent().getNode('$URL').data()
except:
url = node.getNode('$URL').data()
""" request signal """
signal = interface.read_signal(url, time, **kwargs)
""" generate help text (HELP, DESCRIPTION, $NAME) """
try: help = node.getNode('HELP').data()
except:
try: help = node.getNode('DESCRIPTION').data()
except: help = node.getNode('$NAME').data()
signal.setHelp(str(help))
return(signal)
except:
local = locals()
""" generate dummy signal with error message as help text """
import getpass,sys
e = sys.exc_info()
user = getpass.getuser()
help = user+': %s, %d' % (repr(e[1]), e[2].tb_lineno)
print(help)
print(local)
try:
from MDSplus import Signal
signal = Signal([6,66,666])
signal.setHelp(help.split('\n')[-1])
return(signal)
except:
return help
def doScopepanel(self):
def getStringExp(self,name,response_headers):
if name in self.args:
try:
response_headers.append((name,str(Data.execute(self.args[name][-1]).data())))
except Exception:
response_headers.append((name,str(sys.exc_info()[1])))
response_headers=list()
response_headers.append(('Cache-Control','no-store, no-cache, must-revalidate'))
response_headers.append(('Pragma','no-cache'))
if 'tree' in self.args:
Tree.usePrivateCtx()
try:
t=Tree(self.args['tree'][-1],int(self.args['shot'][-1].split(',')[0]))
except:
pass
for name in ('title','xlabel','ylabel','xmin','xmax','ymin','ymax'):
getStringExp(self,name,response_headers)
sig_idx=0
output=''
if 'tree' in self.args:
shots=self.args['shot'][-1].split(',')
for shot in shots:
y_idx=1
y_idx_s='%d' % (y_idx,)
while 'y'+y_idx_s in self.args:
x_idx_s=y_idx_s
sig_idx=sig_idx+1
sig_idx_s='%d' % (sig_idx,)
expr=self.args['y'+y_idx_s][-1]
y_idx=y_idx+1
y_idx_s='%d' % (y_idx,)
try:
t=Tree(self.args['tree'][-1],int(shot))
response_headers.append(('SHOT'+sig_idx_s,str(t.shot)))
except Exception:
response_headers.append(('ERROR'+sig_idx_s,'Error opening tree %s, shot %s, error: %s' % (self.args['tree'][-1],shot,sys.exc_info()[1])))
continue
if 'default_node' in self.args:
try:
t.setDefault(t.getNode(self.args['default_node'][-1]))
except Exception:
response_headers.append(('ERROR'+sig_idx_s,'Error setting default to %s in tree %s, shot %s, error: %s' % (self.args['default_node'][-1],
self.args['tree'][-1],shot,sys.exc_info()[1])))
continue
try:
sig=Data.execute(expr)
y=makeData(sig.data())
except Exception:
response_headers.append(('ERROR' + sig_idx_s,'Error evaluating expression: "%s", error: %s' % (expr,sys.exc_info()[1])))
continue
if 'x'+x_idx_s in self.args:
expr=self.args['x'+x_idx_s][-1]
try:
x=Data.execute(expr)
x=makeData(x.data())
except Exception:
response_headers.append(('ERROR'+sig_idx_s,'Error evaluating expression: "%s", error: %s' % (expr,sys.exc_info()[1])))
continue
else:
try:
x=makeData(sig.dim_of().data())
except Exception:
response_headers.append(('ERROR'+sig_idx_s,'Error getting x axis of %s: "%s", error: %s' % (expr,sys.exc_info()[1])))
continue
response_headers.append(('X'+sig_idx_s+'_DATATYPE',x.__class__.__name__))
response_headers.append(('Y'+sig_idx_s+'_DATATYPE',y.__class__.__name__))
response_headers.append(('X'+sig_idx_s+'_LENGTH',str(len(x))))
response_headers.append(('Y'+sig_idx_s+'_LENGTH',str(len(y))))
output=output+str(x.data().data)+str(y.data().data)
else:
y_idx=1
y_idx_s='%d' % (y_idx,)
while 'y'+y_idx_s in self.args:
x_idx_s = y_idx_s
expr=self.args['y'+y_idx_s][-1]
y_idx=y_idx+1
y_idx_s='%d' % (y_idx,)
sig_idx=sig_idx+1
sig_idx_s='%d' % (sig_idx,)
try:
sig=Data.execute(expr)
y=makeData(sig.data())
except Exception:
response_headers.append(('ERROR' + sig_idx_s,'Error evaluating expression: "%s", error: %s' % (expr,sys.exc_info()[1])))
continue
if 'x'+x_idx_s in self.args:
expr=self.args['x'+x_idx_s][-1]
try:
x=Data.execute(expr)
x=makeData(x.data())
except Exception:
response_headers.append(('ERROR'+sig_idx_s,'Error evaluating expression: "%s", error: %s' % (expr,sys.exc_info()[1])))
continue
else:
try:
x=makeData(sig.dim_of().data())
except Exception:
response_headers.append(('ERROR'+sig_idx_s,'Error getting x axis of %s: "%s", error: %s' % (expr,sys.exc_info()[1])))
continue
response_headers.append(('X'+sig_idx_s+'_DATATYPE',x.__class__.__name__))
response_headers.append(('Y'+sig_idx_s+'_DATATYPE',y.__class__.__name__))
response_headers.append(('X'+sig_idx_s+'_LENGTH',str(len(x))))
response_headers.append(('Y'+sig_idx_s+'_LENGTH',str(len(y))))
output=output+str(x.data().data)+str(y.data().data)
return ('200 OK', response_headers, output)
"""
Created on Wed Aug 12 00:30:33 2015
@author: Cloud
"""
from MDSplus import Tree
def setRecord(node, istop=True):
from MDSplus import TdiCompile
for dec in node.getDescendants():
if dec.getNodeName() == '$URL' and ~istop:
dec.record = TdiCompile('codac_url($)', (node,))
elif dec.usage == 'ANY' and dec.getNodeName() == '$PARLOG':
dec.record = TdiCompile('archive_parlog($,_time)', (node,))
elif dec.getNodeName() == '$CFGLOG':
dec.record = TdiCompile('archive_cfglog($,_time)', (node,))
elif dec.usage == 'SIGNAL':
dec.record = TdiCompile('archive_signal($,_time)', (dec,))
setRecord(dec, False)
tree = Tree('ARCHIVESB', -1)
setRecord(tree.getNode('\TOP'))
