Esempio n. 1
0
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)
Esempio n. 2
0
    def _start_mdsip(self, server, port, logname, protocol=MDSIP_PROTOCOL):
        if port > 0:
            from subprocess import Popen, STDOUT
            logfile = '%s-%s%d.log' % (self.module, logname, self.index)
            log = open(logfile, 'w') if iswin else None
            try:
                hosts = '%s/mdsip.hosts' % self.root
                params = [
                    'mdsip', '-s', '-p',
                    str(port), '-P', protocol, '-h', hosts
                ]

                print(' '.join(params + ['&>', logfile]))
                if not log:
                    params.extend(['2>&1', '|', 'tee', logfile])
                mdsip = Popen(params)
            except:
                if log:
                    log.close()
                raise
            try:
                self._waitIdle(server, 10)  # allow mdsip to launch
            except Exception:
                mdsip.kill()
                raise
        else:
            mdsip, log = None, None
        if server:
            c = Connection(server)
            for envpair in self.envx.items():
                checkStatus(c.get('setenv($//"="//$)', *envpair))
            c.get('tcl($)', 'set verify')
        return mdsip, log
def get_data(signal, shot, tree):

    cn = CN('mds.ipp.ac.cn')
    cn.openTree(tree, shot)
    x = cn.get('\\' + signal).copy()
    t = cn.get('dim_of(' + '\\' + signal + ')').copy()
    cn.closeAllTrees()
    t = np.array(t, dtype=np.float64)
    x = np.array(x, dtype=np.float64)

    return t, x
def read_EAST_TS(shot):
    from MDSplus import Connection as CN
    conn = CN('202.127.204.12')
    conn.openTree('analysis', shot)
    R = conn.get('\\' + 'R_coreTS ').copy()
    Z = conn.get('\\' + 'Z_coreTS ').copy()
    time = conn.get('dim_of(' + '\\' + 'Te_maxTS' + ')').copy()
    Te = conn.get('\\' + 'Te_coreTS ').copy()
    Ne = conn.get('\\' + 'ne_coreTS').copy()
    conn.closeAllTrees()

    return R, Z, time, Te, Ne
Esempio n. 5
0
def data(signal, shot, tree):
    import sys
    sys.path.append("D:\\Program Files\\MDSplus\\python")
    from MDSplus import Connection as CN
    cn = CN('mds.ipp.ac.cn')
    cn.openTree(tree, shot)
    x = cn.get('\\' + signal).copy()
    t = cn.get('dim_of(' + '\\' + signal + ')').copy()
    cn.closeAllTrees()
    t = np.array(t, dtype=np.float64)
    x = np.array(x, dtype=np.float64)

    return t, x
Esempio n. 6
0
 def io(self):
     connection = Connection("thread://io")
     """ mdsconnect """
     self.assertEqual(connection.get('_a=1').tolist(), 1)
     self.assertEqual(connection.get('_a').tolist(), 1)
     self.assertEqual(connection.getObject('1:3:1').__class__, Range)
     g = GetMany(connection)
     g.append('a', '1')
     g.append('b', '$', 2)
     g.append('c', '$+$', 1, 2)
     g.execute()
     self.assertEqual(g.get('a'), 1)
     self.assertEqual(g.get('b'), 2)
     self.assertEqual(g.get('c'), 3)
def fast_read(sig, shot):
    from MDSplus import Connection as CN
    conn = CN('mds.ipp.ac.cn')
    conn.openTree('east', shot)
    x = conn.get('\\' + sig).copy()
    t = conn.get('dim_of(' + '\\' + sig + ')').copy()
    conn.closeAllTrees()
    ind = np.argmin(np.abs(t - 0))
    t = t[ind:]
    x = x[ind:]
    t = np.array(t, dtype=np.float64)
    x = np.array(x, dtype=np.float64)

    return t, x
Esempio n. 8
0
    def threadsTcp(self):
        server, server_port = self._setup_mdsip('ACTION_SERVER', 'ACTION_PORT',
                                                7100 + self.index, True)
        svr = svr_log = None
        try:
            svr, svr_log = self._start_mdsip(server, server_port, 'tcp')
            try:
                if svr is not None: time.sleep(1)

                def requests(c, idx):
                    args = [Float32(i / 10 + idx) for i in range(10)]
                    for i in range(10):
                        self.assertEqual(
                            c.get("[$,$,$,$,$,$,$,$,$,$]", *args).tolist(),
                            args)

                c = Connection(server)
                """ mdsconnect """
                self.assertEqual(c.get('_a=1').tolist(), 1)
                self.assertEqual(c.get('_a').tolist(), 1)
                self.assertEqual(c.getObject('1:3:1').__class__, Range)
                g = GetMany(c)
                g.append('a', '1')
                g.append('b', '$', 2)
                g.append('c', '$+$', 1, 2)
                g.execute()
                self.assertEqual(g.get('a'), 1)
                self.assertEqual(g.get('b'), 2)
                self.assertEqual(g.get('c'), 3)
                threads = [
                    Thread(name="C%d" % i, target=requests, args=(c, i))
                    for i in range(10)
                ]
                for thread in threads:
                    thread.start()
                for thread in threads:
                    thread.join()
            finally:
                if svr and svr.poll() is None:
                    svr.terminate()
                    svr.wait()
        finally:
            if svr_log: svr_log.close()
Esempio n. 9
0
def loadpaths(host, treename):
    """Get the path environment variables for a tree being served by a remote system and
    define them in this process context. The remote system's getpaths function is responsible
    for fixing up the tree_path values, prefixing hostnames and replacing any shortened hostnames
    with fully qualified ip address names."""

    from MDSplus import Connection
    import os
    c = Connection(host)
    paths = c.get("getpaths('%s')" % treename).deserialize()
    for i in range(len(paths['path'])):
        os.environ[paths['tree'][i].rstrip().lower() +
                   '_path'] = paths['path'][i].rstrip()
Esempio n. 10
0
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)
Esempio n. 11
0
 def get(self, expr, *args, **kwargs):
     print 'expression'+expr
     return Connection.get(self, expr, *args, **kwargs)
Esempio n. 12
0
def load_solps_from_mdsplus(mds_server, ref_number):
    """
    Load a SOLPS simulation from a MDSplus server.

    :param str mds_server: Server address.
    :param int ref_number: Simulation reference number.
    :rtype: SOLPSSimulation
    """

    from MDSplus import Connection as MDSConnection

    # Setup connection to server
    conn = MDSConnection(mds_server)
    conn.openTree('solps', ref_number)

    # Load SOLPS mesh geometry and lookup arrays
    mesh = load_mesh_from_mdsplus(conn)
    sim = SOLPSSimulation(mesh)
    ni = mesh.nx
    nj = mesh.ny

    ##########################
    # Magnetic field vectors #
    raw_b_field = np.swapaxes(conn.get('\SOLPS::TOP.SNAPSHOT.B').data(), 0, 2)
    b_field_vectors_cartesian = np.zeros((ni, nj, 3))
    b_field_vectors = np.zeros((ni, nj, 3))
    for i in range(ni):
        for j in range(nj):
            bparallel = raw_b_field[i, j, 0]
            bradial = raw_b_field[i, j, 1]
            btoroidal = raw_b_field[i, j, 2]
            b_field_vectors[i, j] = (bparallel, bradial, btoroidal)

            pv = mesh.poloidal_grid_basis[i, j, 0]  # parallel basis vector
            rv = mesh.poloidal_grid_basis[i, j, 1]  # radial basis vector

            bx = pv.x * bparallel + rv.x * bradial  # component of B along poloidal x
            by = pv.y * bparallel + rv.y * bradial  # component of B along poloidal y
            b_field_vectors_cartesian[i, j] = (bx, btoroidal, by)
    sim._b_field_vectors = b_field_vectors
    sim._b_field_vectors_cartesian = b_field_vectors_cartesian

    # Load electron species
    sim._electron_temperature = np.swapaxes(
        conn.get('\SOLPS::TOP.SNAPSHOT.TE').data(), 0,
        1)  # (32, 98) => (98, 32)
    sim._electron_density = np.swapaxes(
        conn.get('\SOLPS::TOP.SNAPSHOT.NE').data(), 0,
        1)  # (32, 98) => (98, 32)

    ############################
    # Load each plasma species #
    ############################

    # Master list of species, e.g. ['D0', 'D+1', 'C0', 'C+1', ...
    species_list = conn.get('\SOLPS::TOP.IDENT.SPECIES').data()
    try:
        species_list = species_list.decode('UTF-8')
    except AttributeError:  # Already a string
        pass
    sim._species_list = species_list.split()
    sim._species_density = np.swapaxes(
        conn.get('\SOLPS::TOP.SNAPSHOT.NA').data(), 0, 2)
    sim._rad_par_flux = np.swapaxes(
        conn.get('\SOLPS::TOP.SNAPSHOT.FNAY').data(), 0,
        2)  # radial particle flux
    sim._radial_area = np.swapaxes(
        conn.get('\SOLPS::TOP.SNAPSHOT.SY').data(), 0,
        1)  # radial contact area

    # Load the neutral atom density from B2
    dab2 = conn.get('\SOLPS::TOP.SNAPSHOT.DAB2')
    if isinstance(dab2, np.ndarray):
        sim._b2_neutral_densities = np.swapaxes(dab2.data(), 0, 2)

    sim._velocities_parallel = np.swapaxes(
        conn.get('\SOLPS::TOP.SNAPSHOT.UA').data(), 0, 2)
    sim._velocities_radial = np.zeros((ni, nj, len(sim.species_list)))
    sim._velocities_toroidal = np.zeros((ni, nj, len(sim.species_list)))
    sim._velocities_cartesian = np.zeros((ni, nj, len(sim.species_list), 3),
                                         dtype=np.float64)

    ################################################
    # Calculate the species' velocity distribution #
    b2_neutral_i = 0  # counter for B2 neutrals
    for k, sp in enumerate(sim.species_list):

        # Identify the species based on its symbol
        symbol, charge = re.match(_SPECIES_REGEX, sp).groups()
        charge = int(charge)

        # If neutral and B" atomic density available,  use B2 density, otherwise use fluid species density.
        if charge == 0 and (sim._b2_neutral_densities != None):
            species_dens_data = sim.b2_neutral_densities[:, :, b2_neutral_i]
            b2_neutral_i += 1
        else:
            species_dens_data = sim.species_density[:, :, k]

        for i in range(ni):
            for j in range(nj):
                # Load grid basis vectors
                pv = mesh.poloidal_grid_basis[i, j, 0]  # parallel basis vector
                rv = mesh.poloidal_grid_basis[i, j, 1]  # radial basis vector

                # calculate field component ratios for velocity conversion
                bparallel = b_field_vectors[i, j, 0]
                btoroidal = b_field_vectors[i, j, 2]
                bplane = sqrt(bparallel**2 + btoroidal**2)
                parallel_to_toroidal_ratio = bparallel * btoroidal / (bplane**
                                                                      2)

                # Calculate toroidal and radial velocity components
                v_parallel = sim.velocities_parallel[
                    i, j, k]  # straight from SOLPS 'UA' variable
                v_toroidal = v_parallel * parallel_to_toroidal_ratio
                sim.velocities_toroidal[i, j, k] = v_toroidal
                # Special case for edge of mesh, no radial velocity expected.
                try:
                    if species_dens_data[i, j] == 0:
                        v_radial = 0.0
                    else:
                        v_radial = sim.radial_particle_flux[
                            i, j,
                            k] / sim.radial_area[i, j] / species_dens_data[i,
                                                                           j]
                except IndexError:
                    v_radial = 0.0
                sim.velocities_radial[i, j, k] = v_radial

                # Convert velocities to cartesian coordinates
                vx = pv.x * v_parallel + rv.x * v_radial  # component of v along poloidal x
                vy = pv.y * v_parallel + rv.y * v_radial  # component of v along poloidal y
                sim.velocities_cartesian[i, j, k, :] = (vx, v_toroidal, vy)

    # Make Mesh Interpolator function for inside/outside mesh test.
    inside_outside_data = np.ones(mesh.num_tris)
    inside_outside = AxisymmetricMapper(
        Discrete2DMesh(mesh.vertex_coords,
                       mesh.triangles,
                       inside_outside_data,
                       limit=False))
    sim._inside_mesh = inside_outside

    ###############################
    # Load extra data from server #
    ###############################

    ####################
    # Integrated power #
    vol = np.swapaxes(conn.get('\SOLPS::TOP.SNAPSHOT.VOL').data(), 0,
                      1)  # TODO - this should be a mesh property
    linerad = np.swapaxes(conn.get('\SOLPS::TOP.SNAPSHOT.RQRAD').data(), 0, 2)
    linerad = np.sum(linerad, axis=2)
    brmrad = np.swapaxes(conn.get('\SOLPS::TOP.SNAPSHOT.RQBRM').data(), 0, 2)
    brmrad = np.sum(brmrad, axis=2)
    neurad = conn.get('\SOLPS::TOP.SNAPSHOT.ENEUTRAD').data()
    if neurad is not None:  # need to cope with fact that neurad may not be present!!!
        if len(neurad.shape) == 3:
            neurad = np.swapaxes(np.abs(np.sum(neurad, axis=2)), 0, 1)
        else:
            neurad = np.swapaxes(np.abs(neurad), 0, 1)
    else:
        neurad = np.zeros(brmrad.shape)

    total_rad_data = np.zeros(vol.shape)
    ni, nj = vol.shape
    for i in range(ni):
        for j in range(nj):
            total_rad_data[i, j] = (linerad[i, j] + brmrad[i, j] +
                                    neurad[i, j]) / vol[i, j]
    sim._total_rad = total_rad_data

    return sim
Esempio n. 13
0
class JobRunner(object):
    def __init__(self):
        self.use_mdsconnect = False
        self.connection_str = ''
        self.connection = None
        self.g = {}
        self._shot = -1

    def run(self, jobset, skip_init):
        import MDSplus
        from MDSplus import Connection

        self.error = []
        jobs, names = jobset
        self.r = {}
        self.r['error message'] = ['']
        try:
            for k, job in enumerate(jobs):
                for j in job:
                    if j.command == 'connection_mode':
                        if self.connection_str != j.params[0]:
                            self.connection_str = j.params[0]
                            server, port, tree = parse_server_string(
                                self.connection_str)
                            self.use_mdsconnect = (False if server.upper()
                                                   == 'DIRECT' else True)
                            if self.use_mdsconnect:
                                if self.connection is not None:
                                    del self.connection
                                try:
                                    if port != '':
                                        server = server + ':' + port
                                    self.connection = Connection(server)
                                    res = 'ok'
                                except:
                                    res = ('connection error' +
                                           traceback.format_exc())
                            else:
                                if self.connection is not None:
                                    del self.connection
                                    self.connection = None
                                res = 'ok'
                        else:
                            res = 'ok'
                    else:
                        if j.command == 'init':
                            if skip_init:
                                continue
                            else:
                                j.command = 'value'
                        if self.use_mdsconnect:
                            res = self._run_job_mdsconnect(j)
                            if len(self.error) != 0:
                                self.r['error message'] = self.error
                                self.r[names[k]] = res
                                return self.r
                        else:
                            res = self._run_job(j)
                            if len(self.error) != 0:
                                self.r['error message'] = self.error
                                self.r[names[k]] = res
                                return self.r
                self.r[names[k]] = res
        except:
            self.error = ['run error', traceback.format_exc()]
        self.r['error message'] = self.error
        return self.r

    def _run_script_txt(self, job):
        expr = job.params[0]
        try:
            code = compile(expr, '<string>', 'exec')
            g = {}
            l = {}
            exec(code, self.g, self.r)
            return 'ok'
        except:
            self.error = ['Scrip Error', expr, sys.exc_info()[0]]
        return None

    def _run_job_mdsconnect(self, job):
        com = job.command
        if com == 'open':
            tree = job.params[0]
            shot = job.params[1]
            try:
                self.connection.openTree(tree, int(shot))
                return 'ok'
            except:
                self.error = ['run error', traceback.format_exc()]
                return None
            self._shot = shot
        elif com == 'defnode':
            node = job.params[0]
            try:
                if node.strip() != '':
                    self.connection.setDefault(node)
                return 'ok'
            except:
                self.error = ['run error', traceback.format_exc()]
                return None
        elif com == 'value':
            try:
                expr = job.params[0]
                r = self.connection.get(expr).data()
                return r
            except:
                self.error = ['run error', expr, traceback.format_exc()]
                return None
        elif com == 'script_txt':
            return self._run_script_txt(job)

    def _run_job(self, job):
        import MDSplus
        from MDSplus import Connection

        com = job.command

        if com == 'open':
            tree = job.params[0]
            shot = job.params[1]
            try:
                self.t = MDSplus.Tree(tree, int(shot))
                return 'ok'
            except:
                self.error = ['run error', traceback.format_exc()]
                return None
            self._shot = shot
        elif com == 'defnode':
            node = job.params[0]
            try:
                if node.strip() != '':
                    tn = self.t.getNode(node)
                    self.t.setDefault(tn)
                return 'ok'
            except:
                self.error = ['run error', traceback.format_exc()]
                return None
        elif com == 'value':
            try:
                expr = job.params[0]
                r = MDSplus.Data.compile(expr).evaluate().data()
                return r
            except:
                self.error = ['run error', expr, traceback.format_exc()]
                return None
        elif com == 'script_txt':
            return self._run_script_txt(job)
Esempio n. 14
0
    def thick(self):
        def testnci(thick, local, con, nci):
            l = local.S.__getattribute__(nci)
            t = thick.S.__getattribute__(nci)
            if nci.endswith("_nids"):
                l, t = str(l), str(t)
                try:
                    c = str(con.get("getnci(getnci(S,$),'nid_number')", nci))
                except TreeNNF:
                    c = '[]'
            else:
                c = con.get("getnci(S,$)", nci)
            try:
                self.assertEqual(t, c)
                self.assertEqual(t, l)
            except:
                print(nci, t, l, c)
                raise

        server, server_port = self._setup_mdsip('ACTION_SERVER', 'ACTION_PORT',
                                                7000 + self.index, True)

        svr, svr_log = self._start_mdsip(server, server_port, 'thick')
        try:
            con = Connection(server)
            self.assertEqual(
                con.get("zero([1,1,1,1,1,1,1,1],1)").tolist(),
                [[[[[[[[0]]]]]]]])
            with Tree(self.tree, -1, "new") as local:
                local.addNode(self.treesub, "SUBTREE")
                s = local.addNode("S", "SIGNAL")
                s.addTag("tagS")
                s.record = ADD(Float32(1), Float32(2))
                t = local.addNode("T", "TEXT")
                t.addNode("TT", "TEXT").addTag("tagTT")
                t.record = t.TT
                t.TT = "recTT"
                local.write()
            with Tree(self.treesub, -1, "new") as sub:
                sub.addNode("OK")
                sub.write()
            local.normal()
            Tree.setCurrent(self.tree, 7)
            setenv("%s_path" % self.tree, "%s::" % server)
            print(con.get("getenv($//'_path')", self.tree))
            con.get("TreeShr->TreeOpen(ref($),val($),val(1))", self.tree, -1)
            thick = Tree(self.tree, -1)
            thick.createPulse(1)
            thick1 = Tree(self.tree, 1)
            self.assertEqual(
                getattr(local, self.treesub.upper()).OK.nid,
                getattr(thick1, self.treesub.upper()).OK.nid)
            local_filename = local.getFileName()
            thick_filename = thick.getFileName()
            self.assertTrue("::" in thick_filename, thick_filename)
            self.assertTrue(local_filename, thick_filename.split("::", 1)[1])
            """ TreeTurnOff / TreeTurnOn """
            thick.S.on = False
            self.assertEqual(local.S.on, False)
            thick.S.on = True
            self.assertEqual(local.S.on, True)
            """ TreeSetCurrentShotId / TreeGetCurrentShotId """
            Tree.setCurrent(self.tree, 1)
            self.assertEqual(Tree.getCurrent(self.tree), 1)
            """ TreeGetRecord / TreeSetRecord """
            self.assertEqual(str(local.S.record), "1. + 2.")
            self.assertEqual(str(thick.S.record), "1. + 2.")
            thick.S.record = ADD(Float32(2), Float32(4))
            self.assertEqual(str(local.S.record), "2. + 4.")
            self.assertEqual(str(thick.S.record), "2. + 4.")
            self.assertEqual(str(local.T.record), str(thick.T.record))
            """ GetDefaultNid / SetDefaultNid """
            self.assertEqual(thick.getDefault(), thick.top)
            thick.setDefault(thick.S)
            self.assertEqual(thick.getDefault(), thick.top.S)
            thick.setDefault(thick.top)
            """ FindNodeWildRemote """
            self.assertEqual(str(thick.getNodeWild("T*")),
                             str(local.getNodeWild("T*")))
            """ FindTagWildRemote """
            self.assertEqual(thick.findTags("*"), local.findTags("*"))
            """ nci """
            thick.S.write_once = True
            self.assertEqual(thick.S.write_once, True)
            for nci in (
                    'on',
                    'depth',
                    'usage_str',
                    'dtype',
                    'length',
                    'rlength',
                    'fullpath',
                    'minpath',
                    'member_nids',
                    'children_nids',
                    'rfa',
                    'write_once',
            ):
                testnci(thick, local, con, nci)
            """ new stuff """
            self.assertEqual(local.getFileName(),
                             con.get("treefilename($,-1)", self.tree))
        finally:
            if svr_log:
                svr_log.close()
            self._stop_mdsip((svr, server))
Esempio n. 15
0
 def get(self, expr, *args, **kwargs):
     print 'expression' + expr
     return Connection.get(self, expr, *args, **kwargs)
Esempio n. 16
0
        def test():
            from time import sleep
            hosts = '%s/mdsip.hosts' % self.root

            def testDispatchCommand(mdsip, command, stdout=None, stderr=None):
                self.assertEqual(
                    tcl(
                        'dispatch/command/nowait/server=%s %s' %
                        (mdsip, command), 1, 1, 1), (None, None))

            def setup_mdsip(server_env, port_env, default_port, fix0):
                host = getenv(server_env, '')
                if len(host) > 0:
                    return host, 0
                port = int(getenv(port_env, default_port))
                if port == 0:
                    if fix0: port = default_port
                    else: return None, 0
                return 'localhost:%d' % (port, ), port

            def start_mdsip(server, port, logname, env=None):
                if port > 0:
                    from subprocess import Popen, STDOUT
                    logfile = '%s_%d.log' % (logname, self.index)
                    log = open(logfile, 'w')
                    try:
                        params = ['mdsip', '-s', '-p', str(port), '-h', hosts]
                        print(' '.join(params + ['&>', logfile]))
                        mdsip = Popen(params,
                                      env=env,
                                      stdout=log,
                                      stderr=STDOUT)
                    except:
                        log.close()
                        raise
                    return mdsip, log
                if server:
                    for envpair in self.envx.items():
                        testDispatchCommand(server, 'env %s=%s' % envpair)
                return None, None

            monitor, monitor_port = setup_mdsip('ACTION_MONITOR',
                                                'MONITOR_PORT',
                                                8700 + self.index, False)
            monitor_opt = "/monitor=%s" % monitor if monitor_port > 0 else ""
            server, server_port = setup_mdsip('ACTION_SERVER', 'ACTION_PORT',
                                              8800 + self.index, True)
            shot = self.shot + 1
            Tree('pytree', -1, 'ReadOnly').createPulse(shot)
            show_server = "Checking server: %s\n[^,]+, [^,]+, logging enabled, Inactive\n" % server
            pytree = Tree('pytree', shot)
            pytree.TESTDEVICE.ACTIONSERVER.no_write_shot = False
            pytree.TESTDEVICE.ACTIONSERVER.record = server
            """ using dispatcher """
            mon, mon_log, svr, svr_log = (None, None, None, None)
            try:
                mon, mon_log = start_mdsip(monitor, monitor_port, 'monitor')
                svr, svr_log = start_mdsip(server, server_port, 'server',
                                           self.env)
                try:
                    sleep(3)
                    if mon: self.assertEqual(mon.poll(), None)
                    if svr: self.assertEqual(svr.poll(), None)
                    """ mdsconnect """
                    c = Connection(server)
                    self.assertEqual(c.get('1').tolist(), 1)
                    self.assertEqual(c.getObject('1:3:1').__class__, Range)
                    if not sys.platform.startswith(
                            'win'):  # Windows does not support timeout yet
                        try:  #  currently the connection needs to be closed after a timeout
                            Connection(server).get("wait(1)", timeout=100)
                            self.fail(
                                "Connection.get(wait(1)) should have timed out."
                            )
                        except Exc.MDSplusException as e:
                            self.assertEqual(e.__class__, Exc.TdiTIMEOUT)
                    g = GetMany(c)
                    g.append('a', '1')
                    g.append('b', '$', 2)
                    g.append('c', '$+$', 1, 2)
                    g.execute()
                    self.assertEqual(g.get('a'), 1)
                    self.assertEqual(g.get('b'), 2)
                    self.assertEqual(g.get('c'), 3)
                    """ tcl dispatch """
                    self._doTCLTest('show server %s' % server,
                                    out=show_server,
                                    re=True)
                    testDispatchCommand(server, 'set verify')
                    testDispatchCommand(server, 'type test')
                    self._doTCLTest('set tree pytree/shot=%d' % shot)
                    self._doTCLTest('dispatch/build%s' % monitor_opt)
                    self._doTCLTest('dispatch/phase%s INIT' % monitor_opt)
                    sleep(1)
                    self._doTCLTest('show server %s' % server,
                                    out=show_server,
                                    re=True)
                    self._doTCLTest('dispatch/phase%s PULSE' % monitor_opt)
                    sleep(1)
                    self._doTCLTest('show server %s' % server,
                                    out=show_server,
                                    re=True)
                    self._doTCLTest('dispatch/phase%s STORE' % monitor_opt)
                    sleep(1)
                    self._doTCLTest('show server %s' % server,
                                    out=show_server,
                                    re=True)
                    """ 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:
                    try:
                        self._doTCLTest(
                            'dispatch/command/wait/server=%s close/all' %
                            server)
                    finally:
                        if svr and svr.poll() is None:
                            svr.terminate()
                            svr.wait()
                        if mon and mon.poll() is None:
                            mon.terminate()
                            mon.wait()
            finally:
                if svr_log: svr_log.close()
                if mon_log: mon_log.close()
                self._doTCLTest('close/all')
            pytree = Tree('pytree', shot, 'ReadOnly')
            self.assertTrue(pytree.TESTDEVICE.INIT1_DONE.record <=
                            pytree.TESTDEVICE.INIT2_DONE.record)
Esempio n. 17
0
class ForkingTCPRequestHandler(socketserver.StreamRequestHandler):
    #
    def __init__(self, *args, **kargs):
        name = '/tmp/mdsplus_gateway_' + str(os.getpid()) + '.log'

        self.use_mdsconnect = False
        self.connection_str = ''
        self.connection = None
        if write_handler_log:
            self.fid = open(name, 'w')
        else:
            self.fid = None
        socketserver.StreamRequestHandler.__init__(self, *args, **kargs)

    def write_log(self, txt):
        if self.fid is not None:
            self.fid.write(txt + '\n')

    def handle(self):
        try:
            while True:
                self.loop_handler()
        except:
            pass

    def loop_handler(self):
        message = self.rfile.readline().strip()
        if self.fid is not None:
            self.fid.write('handling input \n' + message + '\n')
        asmessage = binascii.a2b_hex(message)
        #        logging.basicConfig(level = logging.DEBUG)
        try:
            data = pickle.loads(asmessage)
        except ValueError as EOFError:
            if self.fid is not None:
                self.fid.write('picke error \n')
                self.fid.flush()


#           logging.exception('picke load error', len(message))
#           response = None
#           return
#cur_thread = threading.current_thread()
        if self.fid is not None:
            self.fid.write('handling request  \n' + str(data) + '\n')
            self.fid.flush()
        r = {}
        for name, commands in data:
            for command in commands:
                com = command[0]
                param = command[1:]
                #cur_thread = threading.current_thread()
                if self.fid is not None:
                    self.fid.write(com + ':' + param + '\n')
                    self.fid.flush()
                if com == 's':

                    server, port, tree = parse_server_string(param)
                    self.use_mdsconnect = (False if server.upper() == 'DIRECT'
                                           else True)

                    if self.use_mdsconnect:
                        try:
                            if self.connection_str != param:
                                del self.connection
                                if port != '':
                                    server = server + ':' + port
                                self.connection = Connection(server)
                                self.connection_str = param
                                r[name] = 'ok'
                        except:
                            r[name] = 'connection error'
                            self.error = [
                                'connection error', self.connection_str
                            ]
                    else:
                        if self.connection is not None:
                            del self.connection
                            self.connection = None
                        self.connection_str = ''
                        r[name] = 'ok'
                else:
                    self.error = []
                    if self.use_mdsconnect:
                        r[name] = self._handle_mdsconnect(com, param)
                    else:
                        r[name] = self._handle(com, param)
                    if len(self.error) != 0:
                        if self.fid is not None:
                            self.fid.write(str(self.error))
                            self.fid.flush()
        if self.fid is not None:
            self.fid.write('return variables  \n' + str(list(r.keys())) + '\n')
            self.fid.flush()

        sr = pickle.dumps(r)
        response = binascii.b2a_hex(sr)
        if self.fid is not None:
            self.fid.write('sending data (length) \n' + str(len(response)) +
                           '\n')
            self.fid.flush()
        self.request.sendall(response + '\n')
        if self.fid is not None:
            self.fid.flush()

    def _handle_mdsconnect(self, com, param):
        response = ''

        self.write_log(str(com) + ':' + str(param))
        if com == 'c':  # connection request
            arr = param.split(',')
            tree = ','.join(arr[:-1])
            shot = arr[-1]
            try:
                if tree != '':
                    self.write_log('opening tree :' + str(tree) + ':' +
                                   str(shot))
                    self.connection.openTree(tree, int(shot))
                response = 'ok'
            except Exception:
                self.error = ['run error', traceback.format_exc()]
                response = None
        elif com == 'd':
            node = param
            self.write_log('setting def node ' + str(node))
            try:
                if node.strip() != '':
                    self.connection.setDefault(node)
                response = 'ok'
            except Exception:
                self.error = ['run error', traceback.format_exc()]
                response = None
        elif com == 'v':  # mdsvalue
            self.write_log('mdsvalue ' + str(param))
            try:
                response = self.connection.get(param).data()
            except Exception:
                self.error = ['run error', param, traceback.format_exc()]
                response = None
        elif com == 'u':  # mdsvalue
            self.write_log('mdsvalue ' + str(param))
            try:
                response = self.connection.get('_piscopevar=execute($)',
                                               param).data()
            except Exception:
                self.error = ['run error', param, traceback.format_exc()]
                response = None
        elif com == 'w':  # dim_of (this is not used anymore)
            self.write_log('dim_of ' + str(param))
            expr = param[1:]
            dim = int(param[0])
            try:
                #               response =MDSplus.Data.compile(param).evaluate().data()
                response = self.connection.get(expr).dim_of(dim).data()
            except Exception:
                self.error = ['run error', param, traceback.format_exc()]
                response = None
        # self.write_log(response.__repr__())
        return response

    def _handle(self, com, param):
        response = ''

        self.write_log(str(com) + ' ' + str(param))
        if com == 'c':  # connection request
            arr = param.split(',')
            tree = ','.join(arr[:-1])
            shot = arr[-1]
            try:
                if tree != '':
                    self.write_log('opening tree ' + str(tree) + ' ' +
                                   str(shot))
                    self.t = MDSplus.Tree(tree, int(shot))
                    self.write_log('opening tree ' + str(self.t))
                response = 'ok'
            except Exception:
                self.error = ['run error', traceback.format_exc()]
                response = None
        elif com == 'd':
            node = param
            self.write_log('setting def node ' + str(node))
            try:
                if node.strip() != '':
                    tn = self.t.getNode(node)
                    self.t.setDefault(tn)
                response = 'ok'
            except Exception:
                self.error = ['run error', traceback.format_exc()]
                response = None
        elif 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)
                response = MDSplus.Data.compile(expr).evaluate().data()
            except Exception:
                self.error = ['run error', expr, traceback.format_exc()]
                response = None
        elif com == 'v':  # mdsvalue
            self.write_log('mdsvalue ' + str(param))
            try:
                response = MDSplus.Data.compile(param).evaluate().data()
            except Exception:
                self.error = ['run error', param, traceback.format_exc()]
                response = None
        elif com == 'u':  # mdsvalue
            self.write_log('mdsvalue ' + str(param))
            try:
                response = MDSplus.Data.execute('_piscopevar=execute($)',
                                                param).data()
            except Exception:
                self.error = ['run error', param, traceback.format_exc()]
                response = None
        elif com == 'w':  # dim_of (this is not used anymore)
            self.write_log('dim_of ' + str(param))
            expr = param[1:]
            dim = int(param[0])
            try:
                #               response =MDSplus.Data.compile(param).evaluate().data()
                response = MDSplus.Data.execute(expr).dim_of(dim).data()
            except Exception:
                self.error = ['run error', param, traceback.format_exc()]
                response = None
        return response
Esempio n. 18
0
class JobRunner(object):
    def __init__(self):
        self.use_mdsconnect = False
        self.connection_str = ''
        self.connection = None
        self.g = {}
        self._shot = -1
        self.gjob = None  # global tdi (executed when shot number changed)
        self._tree = ''
        self._defnode = ''

    def __del__(self):
        if self.connection is not None:
            del self.connection

    def run(self, jobset, skip_init):
        #        def _evaluate_sig(res, sig_names, dim_names):
        #            for name in dim_names:
        #                try:
        #                   src, dim = res[name][0:3].split(',')
        #                   res[name] = res[src].dim_of(long(dim)).data()
        #                except:
        #                   pass
        #            for name in sig_names:
        #                try:
        #                   res[name] = res[name].data()
        #                except:
        #                   pass
        #            return res

        self.error = []
        jobs, names = jobset
        self.r = {'error message': []}
        sig_names = []
        dim_names = []
        try:
            for k, job in enumerate(jobs):
                for j in job:
                    #                print j
                    if j.command == 'connection_mode':
                        #                   print 'connection_mode param', self.connection_str, j.params, self.connection
                        #                   if self.connection is not None:
                        #                        del self.connection
                        #                        self.connection = None

                        if self.connection_str != j.params[0]:
                            #                   if True:
                            server, port, tree = parse_server_string(
                                j.params[0])
                            self.use_mdsconnect = (False if server.upper()
                                                   == 'DIRECT' else True)

                            if self.use_mdsconnect:
                                if self.connection is not None:
                                    del self.connection
                                    self.connection = None
                                try:
                                    if port != '': server = server + ':' + port
                                    self.connection = Connection(server)
                                    self.connection_str = j.params[0]
                                    res = 'ok'
                                except:
                                    self.r['error message'] = [
                                        'connection error' +
                                        traceback.format_exc()
                                    ]
                                    self.r[names[k]] = None
                                    return self.r
                            else:
                                if self.connection is not None:
                                    del self.connection
                                    self.connection = None
                                res = 'ok'
                        else:
                            res = 'ok'
                        self._connection_flag = True
                    else:
                        if j.command == 'init':
                            if skip_init:
                                continue
                            else:
                                j.command = 'value'
                        if self.use_mdsconnect:
                            #                       res = self._run_job_mdsconnect(j, sig_names, dim_names, names[k])
                            #ttt = time.time()
                            res = self._run_job_mdsconnect(j)
                            #print time.time() - ttt, j
                            if len(self.error) != 0:
                                self.r['error message'] = self.error[:]
                                self.r[names[k]] = res
                                return self.r
#                           return _evaluate_sig(self.r, sig_names, dim_names)
                        else:
                            res = self._run_job(j)
                            if len(self.error) != 0:
                                self.r['error message'] = self.error[:]
                                self.r[names[k]] = res
                                return self.r
#                           return _evaluate_sig(self.r, sig_names, dim_names)
                        self._connection_flag = False

                self.r[names[k]] = res
        except:
            self.error = ['run error', traceback.format_exc()]

#        self.r =  _evaluate_sig(self.r, sig_names, dim_names)
        self.r['error message'] = self.error
        return self.r

    def set_globaljob(self, job):
        self.gjob = job

    def terminate(self):
        if self.connection is not None:
            del self.connection
        self.connection = None

    def _run_script_txt(self, job):
        expr = job.params[0]
        try:
            code = compile(expr, '<string>', 'exec')
            g = {}
            l = {}
            exec code in self.g, self.r
            return 'ok'
        except:
            self.error = ['Scrip Error', expr, sys.exc_info()[0]]
        return None

#    def _run_job_mdsconnect(self, job, sig_names,dim_names, name):

    def _run_job_mdsconnect(self, job):
        com = job.command
        if com == 'novalue': return ''
        if debug_runner: print(job)
        #print threading.current_thread().name, com, job.params
        if com == 'open':
            tree = job.params[0]
            shot = job.params[1]
            if self._tree != tree or self._shot != shot:
                try:
                    #print tree,
                    #print long(shot)
                    if tree != '':
                        self.connection.openTree(tree, long(shot))
                except:
                    self.error = ['run error', traceback.format_exc()]
                    return None
            try:
                t = tree.split(',')[0].strip()
                node = '\\' + t + '::TOP'
                if node != self._defnode:
                    self.connection.setDefault(node)
                    self._defnode = node
            except:
                pass
            try:
                if shot != self._shot:
                    expr = 'reset_private();reset_public();1'
                    r = self.connection.get(expr).data()
                if self._connection_flag:
                    if self.gjob is not None:
                        expr = self.gjob.params[0]
                        #print 'performing global tdi', expr
                        r = self.connection.get(expr).data()
                self._connection_flag = False
                self._shot = shot
                self._tree = tree
                return 'ok'
            except:
                self.error = ['run error', traceback.format_exc()]
                return None
        elif com == 'defnode':
            node = job.params[0]
            try:
                if node.strip() != '':
                    if node != self._defnode:
                        self.connection.setDefault(node)
                        self._defnode = node
                return 'ok'
            except:
                print(node)
                self.error = ['run error', traceback.format_exc()]
                return None
        elif com == 'value':
            try:
                expr = job.params[0]
                r = self.connection.get(expr).data()
                return r
            except:
                self.error = ['run error', expr, traceback.format_exc()]
                return None
        elif com == 'valuesig':
            try:
                expr = job.params[0]
                r = self.connection.get('_piscopevar=execute($)', expr).data()
                return r
            except:
                self.error = ['run error', expr, traceback.format_exc()]
                return None
#           elif com == 'dim_of':# this is not used anymore
#               expr = job.params[0]
#               dim_names.append(name)
#               return expr
        elif com == 'script_txt':
            return self._run_script_txt(job)

#    def _run_job(self, job, sig_names, dim_names, name):

    def _run_job(self, job):
        import MDSplus
        from MDSplus import Connection

        com = job.command
        if com == 'novalue': return ''
        if com == 'open':
            tree = job.params[0]
            shot = job.params[1]
            try:
                if tree != '':
                    self.t = MDSplus.Tree(tree, long(shot))
                if shot != self._shot:
                    expr = 'reset_private();reset_public();1'
                    #                      r =MDSplus.Data.compile(expr).evaluate().data()
                    r = MDSplus.Data.execute(expr).data()
                if self._connection_flag:
                    if self.gjob is not None:
                        expr = self.gjob.params[0]
                        r = MDSplus.Data.execute(expr).data()
                self._connection_flag = False
                self._shot = shot
                return 'ok'
            except:
                #                  print traceback.format_exc()
                self.error = ['run error', traceback.format_exc()]
                return None
        elif com == 'defnode':
            node = job.params[0]
            try:
                if node.strip() != '':
                    tn = self.t.getNode(node)
                    self.t.setDefault(tn)
                return 'ok'
            except:
                self.error = ['run error', traceback.format_exc()]
                return None
        elif com == 'value':
            try:
                expr = job.params[0]
                r = MDSplus.Data.execute(expr).data()
                #                  r =MDSplus.Data.execute(expr).data()
                #                 sig_names.append(name)
                return r
            except:
                self.error = ['run error', expr, traceback.format_exc()]
                return None
        elif com == 'valuesig':
            try:
                expr = job.params[0]
                r = MDSplus.Data.execute('_piscopevar=execute($)', expr).data()
                #                  r =MDSplus.Data.execute(expr).data()
                #                 sig_names.append(name)
                return r
            except:
                self.error = ['run error', expr, traceback.format_exc()]
                return None

#           elif com == 'dim_of':     # this is not used anymore
#               expr = job.params[0]  ### expr should be y, 0 (= dim_of(y, 0))
#               dim_names.append(name)
#               return expr
        elif com == 'script_txt':
            return self._run_script_txt(job)
Esempio n. 19
0
class JobRunner(object):
    def __init__(self):
        self.use_mdsconnect = False
        self.connection_str = ''
        self.connection = None
        self.g = {}
        self._shot = -1

    def run(self, jobset, skip_init):
        import MDSplus
        from MDSplus import Connection

        self.error = []
        jobs, names = jobset
        self.r = {}
        self.r['error message'] = ['']
        try:
           for k, job in enumerate(jobs):
              for j in job:
                if j.command == 'connection_mode':
                   if self.connection_str != j.params[0]:
                       self.connection_str = j.params[0]
                       server, port, tree = parse_server_string(self.connection_str)
                       self.use_mdsconnect = (False if server.upper() == 
                                              'DIRECT' else True)
                       if self.use_mdsconnect:
                           if self.connection is not None:
                              del self.connection
                           try:
                               if port != '': server = server + ':' + port
                               self.connection = Connection(server)
                               res = 'ok'                      
                           except:
                               res = ('connection error' + 
                                      traceback.format_exc())
                       else:
                           if self.connection is not None:
                               del self.connection
                               self.connection = None
                           res = 'ok'        
                   else:         
                       res = 'ok'        
                else:
                   if j.command == 'init':
                       if skip_init:
                           continue
                       else:
                           j.command = 'value'
                   if self.use_mdsconnect:
                       res = self._run_job_mdsconnect(j)
                       if len(self.error) != 0:
                           self.r['error message'] = self.error
                           self.r[names[k]] = res
                           return self.r
                   else:
                       res = self._run_job(j)
                       if len(self.error) != 0:
                           self.r['error message'] = self.error
                           self.r[names[k]] = res
                           return self.r
              self.r[names[k]] = res
        except:
           self.error = ['run error', traceback.format_exc()]
        self.r['error message'] = self.error
        return self.r

    def _run_script_txt(self, job):
         expr = job.params[0]
         try:
            code = compile(expr, '<string>', 'exec')
            g = {}
            l = {}
            exec code in self.g, self.r
            return 'ok'
         except:
            self.error = ['Scrip Error', expr, sys.exc_info()[0]]
         return None

    def _run_job_mdsconnect(self, job):
           com = job.command
           if com == 'open':           
               tree = job.params[0]
               shot = job.params[1]
               try:
                  self.connection.openTree(tree, long(shot))
                  return 'ok'
               except:
                  self.error = ['run error', traceback.format_exc()]
                  return None
               self._shot = shot
           elif com == 'defnode':
               node  = job.params[0]
               try:
                  if node.strip() != '':
                     self.connection.setDefault(node)
                  return 'ok'
               except:
                  self.error = ['run error', traceback.format_exc()]
                  return None
           elif com == 'value':
               try:
                   expr = job.params[0]
                   r =self.connection.get(expr).data()
                   return r
               except:
                   self.error = ['run error', expr,traceback.format_exc()]
                   return None
           elif com == 'script_txt':
               return self._run_script_txt(job)

    def _run_job(self, job):
           import MDSplus
           from MDSplus import Connection

           com = job.command

           if com == 'open':           
               tree = job.params[0]
               shot = job.params[1]
               try:
                  self.t = MDSplus.Tree(tree, long(shot))
                  return 'ok'
               except:
                  self.error = ['run error', traceback.format_exc()]
                  return None
               self._shot = shot
           elif com == 'defnode':
               node  = job.params[0]
               try:
                  if node.strip() != '':
                     tn = self.t.getNode(node)
                     self.t.setDefault(tn)
                  return 'ok'
               except:
                  self.error = ['run error', traceback.format_exc()]
                  return None
           elif com == 'value':
               try:
                  expr = job.params[0]
                  r =MDSplus.Data.compile(expr).evaluate().data()
                  return r
               except:
                  self.error = ['run error', expr, traceback.format_exc()]
                  return None
           elif com == 'script_txt':
               return self._run_script_txt(job)
Esempio n. 20
0
start = time()
d = c.Data.execute('random($)', samples).data()
end = time()
print(
    """
Speed test for connection to %s

Using dill for pickling:          %s
Floating point samples retrieved: %d
MBytes received:                  %g
Transaction time in seconds:      %g
Transfer speed in MB/s:           %g
""" %
    (host, usingDill, samples, d.nbytes * 1E-6, end - start, d.nbytes * 1E-6 /
     (end - start)))
c.connection.close()
if mdsip is not None:
    from MDSplus import Connection
    c = Connection(mdsip)
    start = time()
    d = c.get('random($)', samples).data()
    end = time()
    print("""
Speed test for mdsip connection to %s
Floating point samples retrieved: %d
MBytes received:                  %g
Transaction time in seconds:      %g
Transfer speed in MB/s:           %g
""" % (mdsip, samples, d.nbytes * 1E-6, end - start, d.nbytes * 1E-6 /
       (end - start)))
Esempio n. 21
0
def get_input():
    shots = []
    signals = []
    trees = []
    labels = []
    processes = []
    parameters = []

    for i in range(1, 6):
        shot = names['shot' + str(i)].get()

        if len(shot) > 0:
            shot = int(shot)
            shots.append(shot)
        else:
            if i == 1:
                from MDSplus import Connection as CN
                cn = CN('mds.ipp.ac.cn')
                shot = cn.get("current_shot('east')")
                shot = int(shot)
                shots.append(shot)

    for i in range(1, 8):
        signal = names['signal' + str(i)].get()
        tree = names['tree' + str(i)].get()
        label = names['label' + str(i)].get()
        process = names['process' + str(i)].get()
        parameter = names['parameter' + str(i)].get()

        if len(signal) > 0:
            signals.append(signal)
            if len(tree) == 0:
                trees.append('east_1')
            else:
                trees.append(tree)

            if len(label) == 0:
                labels.append(signal)
            else:
                labels.append(label)

            if len(process) == 0:
                processes.append('None')
                parameters.append('None')
            else:
                processes.append(process)
                if len(parameter) == 0:
                    parameters.append('None')
                else:
                    parameter_list = parameter.split(",")
                    parameter = [
                        float(parameter_list[i])
                        for i in range(len(parameter_list))
                    ]
                    parameters.append(parameter)

    begin_time = begin.get()
    end_time = end.get()
    if len(begin_time) == 0:
        begin_time = 0
    if len(end_time) == 0:
        end_time = 10
    begin_time = float(begin_time)
    end_time = float(end_time)

    low_frequency = low_filter.get()
    if len(low_frequency) == 0:
        low_frequency = 0
    low_frequency = int(low_frequency)

    up_frequency = up_filter.get()
    if len(up_frequency) == 0:
        up_frequency = 0
    up_frequency = int(up_frequency)

    return shots, signals, trees, begin_time, end_time, low_frequency, up_frequency, labels, processes, parameters
Esempio n. 22
0
def get_input():

    signals1 = []
    trees1 = []
    labels1 = []
    zooms1 = []
    signals2 = []
    trees2 = []
    labels2 = []
    zooms2 = []
    signals3 = []
    trees3 = []
    labels3 = []
    zooms3 = []
    units = []

    shot = names['shot1'].get()

    if len(shot) > 0:
        shot = int(shot)
    else:
        from MDSplus import Connection as CN
        cn = CN('mds.ipp.ac.cn')
        shot = cn.get("current_shot('east')")
        shot = int(shot)

    for i in range(1, 8):
        signal1 = names['signal1' + str(i)].get()
        tree1 = names['tree1' + str(i)].get()
        label1 = names['label1' + str(i)].get()
        zoom1 = names['zoom1' + str(i)].get()
        signal2 = names['signal2' + str(i)].get()
        tree2 = names['tree2' + str(i)].get()
        label2 = names['label2' + str(i)].get()
        zoom2 = names['zoom2' + str(i)].get()
        signal3 = names['signal3' + str(i)].get()
        tree3 = names['tree3' + str(i)].get()
        label3 = names['label3' + str(i)].get()
        zoom3 = names['zoom3' + str(i)].get()
        unit = names['unit' + str(i)].get()

        if len(signal1) > 0:
            signals1.append(signal1)
            if len(tree1) == 0:
                trees1.append('east_1')
            else:
                trees1.append(tree1)

            if len(label1) == 0:
                labels1.append(signal1)
            else:
                labels1.append(label1)

            if len(zoom1) == 0:
                zooms1.append(1)
            else:
                zooms1.append(float(zoom1))

            if len(signal2) > 0:
                signals2.append(signal2)
                if len(tree2) == 0:
                    trees2.append('east_1')
                else:
                    trees2.append(tree2)

                if len(label2) == 0:
                    labels2.append(signal2)
                else:
                    labels2.append(label2)

                if len(zoom2) == 0:
                    zooms2.append(1)
                else:
                    zooms2.append(float(zoom2))
            else:
                signals2.append('0')
                trees2.append('0')
                labels2.append('0')
                zooms2.append(0)

            if len(signal3) > 0:
                signals3.append(signal3)
                if len(tree3) == 0:
                    trees3.append('east_1')
                else:
                    trees3.append(tree3)

                if len(label3) == 0:
                    labels3.append(signal3)
                else:
                    labels3.append(label3)

                if len(zoom3) == 0:
                    zooms3.append(1)
                else:
                    zooms3.append(float(zoom3))
            else:
                signals3.append('0')
                trees3.append('0')
                labels3.append('0')
                zooms3.append(0)

            if len(unit) > 0:
                units.append(unit)
            else:
                units.append('0')

    begin_time = begin.get()
    end_time = end.get()
    if len(begin_time) == 0:
        begin_time = 0
    if len(end_time) == 0:
        end_time = 10
    begin_time = float(begin_time)
    end_time = float(end_time)

    low_frequency = low_filter.get()
    if len(low_frequency) == 0:
        low_frequency = 0
    low_frequency = int(low_frequency)

    up_frequency = up_filter.get()
    if len(up_frequency) == 0:
        up_frequency = 0
    up_frequency = int(up_frequency)

    return shot, signals1, trees1, labels1, zooms1, signals2, trees2, labels2, zooms2, signals3, trees3, labels3, zooms3, units, begin_time, end_time, low_frequency, up_frequency
Esempio n. 23
0
class JobRunner(object):
    def __init__(self):
        self.use_mdsconnect = False
        self.connection_str = ''
        self.connection = None
        self.g = {}
        self._shot = -1
        self.gjob = None   # global tdi (executed when shot number changed)
        self._tree = ''
        self._defnode = ''
    def __del__(self):
        if self.connection is not None:       
            del self.connection
    def run(self, jobset, skip_init):
#        def _evaluate_sig(res, sig_names, dim_names):
#            for name in dim_names:
#                try:
#                   src, dim = res[name][0:3].split(',')
#                   res[name] = res[src].dim_of(long(dim)).data()
#                except:
#                   pass
#            for name in sig_names:
#                try:
#                   res[name] = res[name].data()
#                except:
#                   pass
#            return res
 

        self.error = []
        jobs, names = jobset
        self.r = {'error message': []}
        sig_names = []
        dim_names = []
        try:
           for k, job in enumerate(jobs):
              for j in job:
#                print j
                if j.command == 'connection_mode':
#                   print 'connection_mode param', self.connection_str, j.params, self.connection
#                   if self.connection is not None:
#                        del self.connection
#                        self.connection = None

                   if self.connection_str != j.params[0]:
#                   if True:
                       server, port, tree = parse_server_string(j.params[0])
                       self.use_mdsconnect = (False if server.upper() == 
                                              'DIRECT' else True)

                       if self.use_mdsconnect:
                           if self.connection is not None:
                               del self.connection
                               self.connection = None
                           try:
                               if port != '': server = server + ':' + port
                               self.connection = Connection(server)
                               self.connection_str = j.params[0]
                               res = 'ok'                      
                           except:
                               self.r['error message'] = ['connection error' + 
                                      traceback.format_exc()]
                               self.r[names[k]] = None
                               return self.r
                       else:
                           if self.connection is not None:
                               del self.connection
                               self.connection = None
                           res = 'ok'        
                   else:         
                       res = 'ok'    
                   self._connection_flag = True    
                else:
                   if j.command == 'init':
                       if skip_init:
                           continue
                       else:
                           j.command = 'value'
                   if self.use_mdsconnect:
#                       res = self._run_job_mdsconnect(j, sig_names, dim_names, names[k])
                       #ttt = time.time()
                       res = self._run_job_mdsconnect(j)
                       #print time.time() - ttt, j
                       if len(self.error) != 0:
                           self.r['error message'] = self.error[:]
                           self.r[names[k]] = res
                           return self.r
#                           return _evaluate_sig(self.r, sig_names, dim_names)
                   else:
                       res = self._run_job(j)
                       if len(self.error) != 0:
                           self.r['error message'] = self.error[:]
                           self.r[names[k]] = res
                           return self.r
#                           return _evaluate_sig(self.r, sig_names, dim_names)
                   self._connection_flag = False    

              self.r[names[k]] = res
        except:
           self.error = ['run error', traceback.format_exc()]

#        self.r =  _evaluate_sig(self.r, sig_names, dim_names)
        self.r['error message'] = self.error
        return self.r

    def set_globaljob(self, job):
        self.gjob = job

    def terminate(self):
        if self.connection is not None:
            del self.connection
        self.connection = None


    def _run_script_txt(self, job):
         expr = job.params[0]
         try:
            code = compile(expr, '<string>', 'exec')
            g = {}
            l = {}
            exec code in self.g, self.r
            return 'ok'
         except:
            self.error = ['Scrip Error', expr, sys.exc_info()[0]]
         return None

#    def _run_job_mdsconnect(self, job, sig_names,dim_names, name):
    def _run_job_mdsconnect(self, job):
           com = job.command
           if com == 'novalue': return ''
           if debug_runner: print(job)
           #print threading.current_thread().name, com, job.params
           if com == 'open':           
               tree = job.params[0]
               shot = job.params[1]
               if self._tree != tree or self._shot != shot: 
                  try:
                     #print tree, 
                     #print long(shot)
                     if tree != '':
                         self.connection.openTree(tree, long(shot))
                  except:
                     self.error = ['run error', traceback.format_exc()]
                     return None
               try:
                  t = tree.split(',')[0].strip()
                  node = '\\'+ t +'::TOP'
                  if node != self._defnode:
                     self.connection.setDefault(node)
                     self._defnode = node
               except:
                  pass 
               try:
                  if shot != self._shot:
                      expr = 'reset_private();reset_public();1'
                      r =self.connection.get(expr).data()
                  if self._connection_flag:
                      if self.gjob is not None:
                         expr = self.gjob.params[0]
                         #print 'performing global tdi', expr
                         r =self.connection.get(expr).data()
                  self._connection_flag = False
                  self._shot = shot
                  self._tree = tree
                  return 'ok'
               except:
                  self.error = ['run error', traceback.format_exc()]
                  return None
           elif com == 'defnode':
               node  = job.params[0]
               try:
                  if node.strip() != '':
                     if node != self._defnode:
                        self.connection.setDefault(node)
                        self._defnode = node
                  return 'ok'
               except:
                  print(node)
                  self.error = ['run error', traceback.format_exc()]
                  return None
           elif com == 'value':
               try:
                   expr = job.params[0]
                   r =self.connection.get(expr).data()
                   return r
               except:
                   self.error = ['run error', expr,traceback.format_exc()]
                   return None
           elif com == 'valuesig':
               try:
                   expr = job.params[0]
                   r =self.connection.get('_piscopevar=execute($)', expr).data()
                   return r
               except:
                   self.error = ['run error', expr,traceback.format_exc()]
                   return None
#           elif com == 'dim_of':# this is not used anymore
#               expr = job.params[0]
#               dim_names.append(name)
#               return expr
           elif com == 'script_txt':
               return self._run_script_txt(job)

#    def _run_job(self, job, sig_names, dim_names, name):
    def _run_job(self, job):
           import MDSplus
           from MDSplus import Connection

           com = job.command
           if com == 'novalue': return ''
           if com == 'open':           
               tree = job.params[0]
               shot = job.params[1]
               try:
                  if tree != '':
                      self.t = MDSplus.Tree(tree, long(shot))
                  if shot != self._shot:
                      expr = 'reset_private();reset_public();1'
#                      r =MDSplus.Data.compile(expr).evaluate().data()
                      r =MDSplus.Data.execute(expr).data()
                  if self._connection_flag:
                      if self.gjob is not None:
                         expr = self.gjob.params[0]
                         r =MDSplus.Data.execute(expr).data()
                  self._connection_flag = False
                  self._shot = shot
                  return 'ok'
               except:
#                  print traceback.format_exc()
                  self.error = ['run error', traceback.format_exc()]
                  return None
           elif com == 'defnode':
               node  = job.params[0]
               try:
                  if node.strip() != '':
                     tn = self.t.getNode(node)
                     self.t.setDefault(tn)
                  return 'ok'
               except:
                  self.error = ['run error', traceback.format_exc()]
                  return None
           elif com == 'value':
               try:
                  expr = job.params[0]
                  r =MDSplus.Data.execute(expr).data()
#                  r =MDSplus.Data.execute(expr).data()
#                 sig_names.append(name)
                  return r
               except:
                  self.error = ['run error', expr, traceback.format_exc()]
                  return None
           elif com == 'valuesig':
               try:
                  expr = job.params[0]
                  r =MDSplus.Data.execute('_piscopevar=execute($)', expr).data()
#                  r =MDSplus.Data.execute(expr).data()
#                 sig_names.append(name)
                  return r
               except:
                  self.error = ['run error', expr, traceback.format_exc()]
                  return None

#           elif com == 'dim_of':     # this is not used anymore
#               expr = job.params[0]  ### expr should be y, 0 (= dim_of(y, 0))
#               dim_names.append(name)
#               return expr
           elif com == 'script_txt':
               return self._run_script_txt(job)