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 arrayDimensionOrder(self):
from numpy import int16, zeros
from random import randint
ptree = Tree('seg_tree', -1, 'NEW')
ptree.addNode('IMM')
ptree.write()
ptree = Tree('seg_tree', -1)
ptree.createPulse(1)
ptree = Tree('seg_tree', 1)
node = ptree.getNode('IMM')
WIDTH = 640
HEIGHT = 480
currFrame = zeros(WIDTH * HEIGHT, dtype=int16)
currTime = float(0)
for i in range(0, WIDTH):
for j in range(0, HEIGHT):
currFrame[i * HEIGHT + j] = randint(0, 255)
currTime = float(0)
startTime = Float32(currTime)
endTime = Float32(currTime)
dim = Float32Array(currTime)
segment = Int16Array(currFrame)
segment.resize([1, HEIGHT, WIDTH])
shape = segment.getShape()
node.makeSegment(startTime, endTime, dim, segment)
retShape = node.getShape()
self.assertEqual(shape[0], retShape[0])
self.assertEqual(shape[1], retShape[1])
self.assertEqual(shape[2], retShape[2])
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 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():
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 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 openTrees(self):
with Tree('pytree',self.shot+1,'new'): pass
filepath = ('%s/pytree_%03d.tree'%(self.tmpdir,self.shot+1)).replace(os.sep,'/')
self.assertEqual(Tree.getFileName('pytree',self.shot+1), filepath)
pytree = Tree('pytree',self.shot+1)
self.assertEqual(pytree.getFileName(), filepath)
self.assertEqual(str(pytree),'Tree("PYTREE",%d,"Normal")'%(self.shot+1,))
pytree.createPulse(self.shot+2)
self.assertEqual(pytree.number_opened,1)
if not Tests.inThread:
Tree.setCurrent('pytree',self.shot+2)
pytree2=Tree('pytree',0)
self.assertEqual(str(pytree2),'Tree("PYTREE",%d,"Normal")'%(self.shot+2,))
self.assertEqual(pytree2.incrementCurrent(1000),self.shot+1002)
self.assertEqual(pytree2.getCurrent(),self.shot+1002)
pytree2.setCurrent()
self.assertEqual(Tree.getCurrent('pytree'),self.shot+2)
else:
pytree2=Tree('pytree',self.shot+2)
self.assertEqual(pytree2.number_opened,1)
self.assertEqual(pytree.shotid,pytree.shot)
self.assertEqual(pytree.tree,pytree.expt)
self.assertEqual(pytree.max_open,8)
try: pytree.versions_in_model = True
except TreeNOEDIT: pass
else: self.assertEqual("TreeSUCCESS","TreeNOEDIT")
try: pytree.versions_in_pulse = True
except TreeNOEDIT: pass
else: self.assertEqual("TreeSUCCESS","TreeNOEDIT")
def test():
from MDSplus import Tree, Float32, Float32Array, Int16Array
from numpy import int16, zeros
from random import randint
with Tree(self.tree, self.shot, 'NEW') as ptree:
node = ptree.addNode('IMM')
ptree.write()
node.tree = Tree(self.tree, self.shot)
WIDTH = 64
HEIGHT = 48
currFrame = zeros(WIDTH * HEIGHT, dtype=int16)
currTime = float(0)
for i in range(0, WIDTH):
for j in range(0, HEIGHT):
currFrame[i * HEIGHT + j] = randint(0, 255)
currTime = float(0)
startTime = Float32(currTime)
endTime = Float32(currTime)
dim = Float32Array(currTime)
segment = Int16Array(currFrame)
segment.resize([1, HEIGHT, WIDTH])
shape = segment.getShape()
node.makeSegment(startTime, endTime, dim, segment)
retShape = node.getShape()
self.assertEqual(shape[0], retShape[0])
self.assertEqual(shape[1], retShape[1])
self.assertEqual(shape[2], retShape[2])
def copy_tree(shot):
tree_raw = Tree('exl50', shot)
tree_cop = Tree('exl50_copy', shot, 'NEW')
pools = ["AI", "FBC"]
for pool in pools:
# nodes_list = []
nodes_array = tree_raw.getNode(pool).getDescendants()
# nodes_list.extend(nodes_array)
pool_nodes = [node.getNodeName() for node in nodes_array]
tree_raw.setDefault(tree_raw.getNode(pool))
tree_cop.setDefault(tree_cop.addNode(pool, "STRUCTURE"))
for node in pool_nodes:
tree_cop.addNode(node, "SIGNAL").addTags(node)
# print(node)
try:
data = tree_raw.getNode(node).getData()
tree_cop.getNode(node).putData(data)
print(str(shot) + ':' + node)
except Exception as e:
pass
tree_raw.setDefault(tree_raw.getNode(r"\EXL50::TOP"))
tree_cop.setDefault(tree_cop.getNode(r"\EXL50_COPY::TOP"))
# tree_raw.setDefault(node.getParent())
# tree_cop.setDefault(node.getParent())
tree_cop.write()
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 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 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 openTrees(self):
pytree = Tree('pytree', self.shot)
self.assertEqual(str(pytree),
'Tree("PYTREE",%d,"Normal")' % (self.shot, ))
pytree.createPulse(self.shot + 1)
if not treeTests.inThread:
Tree.setCurrent('pytree', self.shot + 1)
pytree2 = Tree('pytree', 0)
self.assertEqual(str(pytree2),
'Tree("PYTREE",%d,"Normal")' % (self.shot + 1, ))
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 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 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 test():
filepath = ('%s/pytree_%03d.tree' %
(self.tmpdir, self.shot)).replace(os.sep, '/')
self.assertEqual(Tree.getFileName('pytree', self.shot), filepath)
pytree = Tree('pytree', self.shot)
self.assertEqual(pytree.getFileName(), filepath)
self.assertEqual(str(pytree),
'Tree("PYTREE",%d,"Normal")' % (self.shot, ))
pytree.createPulse(self.shot + 1)
if not Tests.inThread:
Tree.setCurrent('pytree', self.shot + 1)
pytree2 = Tree('pytree', 0)
self.assertEqual(
str(pytree2),
'Tree("PYTREE",%d,"Normal")' % (self.shot + 1, ))
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 open(self):
shot1 = self.shot + 1
shot2 = shot1 + 1
with Tree('pytree', shot1, 'new') as pytree:
a = pytree.addNode('A', 'TEXT')
pytree.write()
pytree.open()
a.record = 'a' * 64
self.assertEqual(pytree.getDatafileSize(), 84)
pytree.close()
with Tree('pytree', shot1, 'new') as pytree:
# new should clear datafile (O_TRUNC)
self.assertEqual(pytree.getDatafileSize(), 0)
filepath = ('%s/pytree_%03d.tree' % (self.tmpdir, shot1)).replace(
os.sep, '/')
self.assertEqual(Tree.getFileName('pytree', shot1), filepath)
pytree = Tree('pytree', shot1)
self.assertEqual(pytree.getFileName(), filepath)
self.assertEqual(str(pytree), 'Tree("PYTREE",%d,"Normal")' % (shot1, ))
pytree.createPulse(shot2)
self.assertEqual(pytree.number_opened, 1)
if not Tests.inThread:
Tree.setCurrent('pytree', shot2)
pytree2 = Tree('pytree', 0)
self.assertEqual(str(pytree2),
'Tree("PYTREE",%d,"Normal")' % (shot2, ))
self.assertEqual(pytree2.incrementCurrent(1000), shot2 + 1000)
self.assertEqual(pytree2.getCurrent(), shot2 + 1000)
pytree2.setCurrent()
self.assertEqual(Tree.getCurrent('pytree'), shot2)
else:
pytree2 = Tree('pytree', shot2)
self.assertEqual(pytree2.number_opened, 1)
self.assertEqual(pytree.shotid, pytree.shot)
self.assertEqual(pytree.tree, pytree.expt)
self.assertEqual(pytree.max_open, 8)
try:
pytree.versions_in_model = True
except TreeNOEDIT:
pass
else:
self.assertEqual("TreeSUCCESS", "TreeNOEDIT")
try:
pytree.versions_in_pulse = True
except TreeNOEDIT:
pass
else:
self.assertEqual("TreeSUCCESS", "TreeNOEDIT")
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 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 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 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)
