def get_mds_active_probes(shot, tunnel=True): """ Get the probes that were active during the shot. Used in main function. shot: the shot you want """ # MDSplus connection to atlas where the data is store on the "LANGMUIR" tree. if tunnel: conn = mds.Connection("localhost") else: conn = mds.Connection('atlas.gat.com') conn.openTree("LANGMUIR", shot) tmin = conn.get("\LANGMUIR::TOP.TMIN").data() tmax = conn.get("\LANGMUIR::TOP.TMAX").data() runid = conn.get("\LANGMUIR::TOP.RUNID").data() mds_index = [] found_probes = [] for mds_pnum in range(1, 85): # Make sure probe name is in correct formart: 001, 002, ... , 084, 085. if mds_pnum < 10: probe = "00" + str(mds_pnum) else: probe = "0" + str(mds_pnum) # The complete path name to the lp. PNUM is the probe number, which does # not match its number in mdsplus (001 - 085). pname = "\LANGMUIR::TOP.PROBE_" + probe + ".PNUM" # Get the actual probe number if it is there. Not all MDS probes are used. try: check_pnum = conn.get(pname).data() except: pass #print "No data in probe " + str(probe) + "." # It will be '0' or blank if the MDS entry isn;t used. Otherwise it will # have the actual probe number in it. if check_pnum > 0: print("Probe " + str(check_pnum) + " is MDS probe " + str(mds_pnum)) mds_index.append(mds_pnum) found_probes.append(check_pnum) number_of_probes = len(found_probes) print("Found data for " + str(number_of_probes) + " probes.") # Store in dictionary and return it. active = {} active["tmin"] = tmin active["tmax"] = tmax active["runid"] = runid active["probes"] = found_probes active["mds_index"] = mds_index return active
def get_mds_lp_data(shot, mds_index, tunnel=True): """ Get LP data for a single probe. Used in main function. shot: the shot you want mds_index: a number 1-85 that corresponds to the mds node. These do not match the probe number (which is PNUM). """ # MDS connection required through atlas tunnel. if tunnel: conn = mds.Connection("localhost") else: conn = mds.Connection("atlas.gat.com") conn.openTree("LANGMUIR", shot) # Use correct form of probe name. if mds_index < 10: probe = "00" + str(mds_index) else: probe = "0" + str(mds_index) pname = "\LANGMUIR::TOP.PROBE_" + probe # All the data stored in a dictionary. All the data is in the subtree # indicated in pname. Just specify the node and grab the data. lp_data = {} lp_data["time"] = conn.get(pname + ":TIME").data() lp_data["rprobe"] = conn.get(pname + ":R").data() lp_data["zprobe"] = conn.get(pname + ":Z").data() lp_data["label"] = conn.get(pname + ":LABEL").data() lp_data["ntimes"] = conn.get(pname + ":NTIMES").data() lp_data["pnum"] = conn.get(pname + ":PNUM").data() lp_data["isat"] = conn.get(pname + ":ISAT").data() lp_data["jsat"] = conn.get(pname + ":JSAT").data() lp_data["temp"] = conn.get(pname + ":TEMP").data() lp_data["dens"] = conn.get(pname + ":DENS").data() lp_data["pot"] = conn.get(pname + ":POT").data() lp_data["psin"] = conn.get(pname + ":PSIN").data() lp_data["angle"] = conn.get(pname + ":ANGLE").data() lp_data["area"] = conn.get(pname + ":AREA").data() lp_data["delrsepout"] = conn.get(pname + ":DELRSEPOUT").data() lp_data["delrsepin"] = conn.get(pname + ":DELRSEPIN").data() lp_data["delzsepout"] = conn.get(pname + ":DELZSEPOUT").data() lp_data["delzsepin"] = conn.get(pname + ":DELZSEPIN").data() lp_data["csq"] = conn.get(pname + ":CSQ").data() lp_data["res_err"] = conn.get(pname + ":RES_ERR").data() lp_data["heatflux"] = conn.get(pname + ":HEATFLUX").data() lp_data["pnum"] = conn.get(pname + ":PNUM").data() #print "Data stored for probe " + str(lp_data["pnum"]) + " (MDS index " + str(mds_index) + ")." return lp_data
def dl_dbs_ch(shot: int, pname: 'pointname') -> ('signal', 'time'): import MDSplus conn = MDSplus.Connection("atlas.gat.com") print(f"Starting {shot}'s {pname}...") dat = np.array(conn.get(r"_s=ptdata($,$)", pname, shot)) del conn return dat, pname
def get_dict_of_lps(shot): """ Run this function to get the Langmuir probe data in a dictionary of dictionaries. Each entry will be all the probe data in the form of a dictionary (it just sound confusing in word it isn't really that weird). shot: the shot you want the data for. """ start = time.time() # MDS connection required through atlas tunnel. conn = mds.Connection("atlas.gat.com") conn.openTree("LANGMUIR", shot) # Get a dictionary with the probe active during this shot. active = get_mds_active_probes(conn, shot) print() # Get a dictionary of each probe data, then store it all in one big dictionary. lps = {} for mds_index in active["mds_index"]: lp_data = get_mds_lp_data(conn, shot, mds_index) probe_name = "probe " + str(lp_data["pnum"]) lps[probe_name] = lp_data print("Data stored for " + str(probe_name) + " (MDS index " + str(mds_index) + ").") end = time.time() elapsed = end - start print("Time elapsed: " + str(elapsed)) return lps
def run(shot, tag, units, mult=1): conn = mds.Connection('localhost') ga_obj = gadata(tag, shot, connection=conn) time = ga_obj.xdata value = ga_obj.zdata * mult fig = pp.pplot(time, value, fmt='-', xlabel='Time (ms)', ylabel=tag.upper() + ' (' + units + ')', xrange=[0, 6000]) minmax = input( 'Enter time min/max for analysis range (separated by commas): ').split( ',') min_idx = np.where(time > float(minmax[0]))[0][0] max_idx = np.where(time > float(minmax[1]))[0][0] avg_value = np.mean(value[min_idx:max_idx]) # Convert from kW to MW. print('Average {}: {:.3f} {}'.format(tag.upper(), avg_value, units)) return ga_obj
def plot_bolo(shot, tmin=2000, tmax=5000, exclude_chords=[]): bolo_dict = {} bolo_zdata = None conn = MDSplus.Connection('localhost') fig = plt.figure() ax1 = fig.add_subplot(111) for chord in range(1, 25): print('Chord {}'.format(chord)) point_name = 'BOL_U' + format(chord, '02d') + '_P' bolo_data = gadata(point_name, shot=shot, connection=conn) min_idx = np.where(bolo_data.xdata < tmin)[0][0] max_idx = np.where(bolo_data.xdata > tmax)[0][0] if bolo_zdata is None: bolo_zdata = np.zeros((24, max_idx - min_idx)) if chord in exclude_chords: continue #print(bolo_data.zdata[min_idx:max_idx]) bolo_zdata[chord-1] = bolo_data.zdata[min_idx:max_idx] # Flip bolo_zdata upside down so that topmost chord (24) is on the top in the graph. bolo_zdata = np.flipud(bolo_zdata) ax1.pcolor(bolo_zdata) fig.show() return bolo_zdata
def current_shot(): global _AURORA try: return int(_AURORA.get('current_shot("mst")')) except: _AURORA = mds.Connection('aurora.physics.wisc.edu') return int(_AURORA.get('current_shot("mst")'))
def getBtVac(self): """Returns vacuum toroidal field on-axis. We use MDSplus.Connection for a proper use of the TDI function tcv_eq() Returns: BtVac (Array): [nt] array of vacuum toroidal field. Raises: ValueError: if module cannot retrieve data from MDS tree. """ if self._btaxv is None: try: # constant is due to a detailed measurements on the vacuum vessel major radius # introduce to be consistent with TDI function tcv_eq.fun RMaj = 0.88 / 0.996 # almost 0.88 m # open a connection conn = MDSplus.Connection('tcvdata.epfl.ch') conn.openTree('tcv_shot', self._shot) bt = conn.get('tcv_eq("BZERO")').data()[0] / RMaj btTime = conn.get('dim_of(tcv_eq("BZERO"))').data() conn.closeTree(self._tree, self._shot) # we need to interpolate on the time basis of LIUQE self._btaxv = scipy.interp(self.getTimeBase(), btTime, bt) self._defaultUnits['_btaxv'] = 'T' except: raise ValueError('data retrieval failed.') return self._btaxv.copy()
def data(signal, shot, **kw): if 'tree' in kw: tree = kw['tree'] else: tree = 'east' cn = mds.Connection('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) if 'timerange' in kw: timerange = kw['timerange'] index = np.where((t >= np.min(timerange)) & (t <= np.max(timerange))) t = t[index] x = x[index] judge = signal[0:2] if judge == "G1": temp = x x = 10**(temp * 1.667 - 9.333) elif judge == "PA" or judge == "PJ": temp = x x = 2e3 * temp elif judge == "PP" or judge == "PD": temp = x x = 2e4 * temp if 'medfilt' in kw: n = kw['medfilt'] x = sig.medfilt(x, n) if 'move' in kw: move = kw['move'] t = t - move if 'smooth' in kw: win = kw['smooth'][0] k = kw['smooth'][1] x = sig.savgol_filter(x, win, k) if 'log' in kw: if kw['log'] == 10: x = np.log10(x) elif kw['log'] == 2: x = np.log2(x) else: x = np.log(x) if 'zoom' in kw: n = kw['zoom'] x = n * x return t, x
def dl_dbs_t(shot: int) -> None: import MDSplus conn = MDSplus.Connection('atlas.gat.com') dat = np.array(conn.get(f"_s=ptdata2('d1a', {shot})")) t = np.array(conn.get("dim_of(_s)")) print(f"Shot {shot}'s d1a and time received.") del conn return dat, t
def check_open_tree(shot_number, server, tree): try: con = mds.Connection(server) con.openTree(tree, shot_number) return True except (mds.MdsIpException, mds.TreeFOPENR, mds.TdiMISS_ARG) as e: logger.warning('Error opening shot %d' % shot_number) return False
def __init__(self, name='nstxu', shotlist=None, xp=None, date=None): self._shots = {} # shot dictionary with shot number (int) keys self._classlist = {} self._name = machineAlias(name) self._logbook = Logbook(name=self._name, root=self) event_server = EVENT_SERVERS[self._name] self._eventConnection = mds.Connection('{}:{}'.format( event_server['hostname'], event_server['port'])) if len(self._connections) is 0: mds_server = MDS_SERVERS[self._name] for _ in range(2): connection = mds.Connection('{}:{}'.format( mds_server['hostname'], mds_server['port'])) connection.tree = None self._connections.append(connection) self.s0 = Shot(0, root=self, parent=self) if shotlist or xp or date: self.addshot(shotlist=shotlist, xp=xp, date=date)
def plot_avg_bolo(shots, tmin=2000, tmax=5000, exclude_chords=[]): conn = MDSplus.Connection('localhost') all_bolo = None shot_count = 0 for shot in shots: print("Shot {}".format(shot)) # Get data for this shot. bolo_zdata = None for chord in range(1, 25): point_name = 'BOL_U' + format(chord, '02d') + '_P' bolo_data = gadata(point_name, shot=shot, connection=conn) # Restrict the data to the desired time range. Only need to find # once since each chord shares the same time index. if bolo_zdata is None: min_idx = np.where(bolo_data.xdata < tmin)[0][0] max_idx = np.where(bolo_data.xdata > tmax)[0][0] bolo_zdata = np.zeros((24, max_idx - min_idx)) # Don't include the bad chords. if chord in exclude_chords: continue # Put this chord into the array for this shot. bolo_zdata[chord-1] = bolo_data.zdata[min_idx:max_idx] # Now flip the bolo_zdata so the topmost chord is the top row (for plotting). #bolo_zdata = np.flipud(bolo_zdata) # Create the array to hold all the data now. if all_bolo is None: all_bolo = np.zeros((len(shots), 24, max_idx-min_idx)) # Put this shot's bolo data into the array. all_bolo[shot_count] = bolo_zdata shot_count += 1 # Now that we have all the data for each shot in a 3D array, average along # the axis to make this a 2D array of the average data. avg_bolo = np.mean(all_bolo, axis=0) avg_bolo_x = np.linspace(tmin, tmax, len(avg_bolo[0])) avg_bolo_y = np.arange(0, 25, 1) # Plot it up. fig = plt.figure(figsize=(7,5)) ax1 = fig.add_subplot(111) ax1.pcolor(avg_bolo_x, avg_bolo_y, avg_bolo) ax1.set_xlim([tmin, tmax]) ax1.set_xlabel('Time (ms)') ax1.set_ylabel('Chord') fig.tight_layout() fig.show() return avg_bolo
def data1(signal, shot, tree='east'): cn = mds.Connection('mds.ipp.ac.cn') cn.openTree(tree, shot) x = cn.get('\\' + signal).copy() cn.closeAllTrees() x = np.array(x, dtype=np.float64) return x
def _retrieve_signal(shot_number, server, tree, xstring, ystring, name, color): try: con = mds.Connection(server) con.openTree(tree, shot_number) logger.debug("Retrieving data for %s" % name) data = retrieve_data(con, xstring, ystring, name, color) return data except (mds.MdsIpException, mds.TreeFOPENR, mds.TdiMISS_ARG) as e: logger.warning('Random MDSplus error in retrieve_signal') return
def __init__(self, name='nstxu', shotlist=None, xp=None, date=None): self._shots = {} # shot dictionary with shot number (int) keys self._classlist = {} self._name = machineAlias(name) if VERBOSE: print('{}.__init__'.format(self._name)) self._logbook = Logbook(name=self._name, root=self) self._eventConnection = mds.Connection(EVENT_SERVERS[self._name]) if len(self._connections) is 0: if VERBOSE: print('{}.__init__ Precaching MDS connections...'. format(self._name)) for _ in range(2): try: connection = mds.Connection(MDS_SERVERS[self._name]) connection.tree = None self._connections.append(connection) except: msg = 'MDSplus connection to {} failed'.format( MDS_SERVERS[self._name]) raise FdpError(msg) if VERBOSE: print('{}.__init__ Finished MDS'.format(self._name)) self.s0 = Shot(0, root=self, parent=self) if shotlist or xp or date: self.addshot(shotlist=shotlist, xp=xp, date=date)
def flat_top(shot): # Load densv2 tag data. conn = mds.Connection('localhost') ga_obj = gadata('densv2', shot, connection=conn) time = ga_obj.xdata dens = ga_obj.zdata # Plot and ask for the flat top range. fig = pp.pplot(time, dens, fmt='-', xlabel='Time (ms)', ylabel=r'$\mathrm{\bar{n_e}\ (m^{-3})}$') minmax = input('Enter time min/max for analysis range (separated by commas): ').split(',') # Return requested time range for use in TS function (min, max). return int(minmax[0]), int(minmax[1])
def getshots(expt_path,lower,upper): if expt_path.find('::')>=0: # path is referring to remote tree server,path = expt_path.split('::',2) # check if thick or distributed path = "*" if len(path)==0 else '"'+path+'"' # handle None for upper and lower if lower is None: lower = "*" if upper is None: upper = "*" # fetch data from server return MDSplus.Connection(server).get('getShotDb("%s",%s,%s,%s)'%(expt,path,str(lower),str(upper)),).data().tolist() start = expt+'_' files = [f[len(expt):-5].split('_') for f in os.listdir(expt_path) if f.endswith('.tree') and f.startswith(start)] return [int(f[1]) for f in files if len(f)==2 and f[1]!='model']
def get_current_shot(server, tree): try: con = mds.Connection(server) con.openTree(tree, 0) current_shot = int(con.get("$SHOT")) return current_shot except mds.mdsExceptions.TreeNOCURRENT as e: logger.warning('TreeNOCURRENT in get_current_shot') return except (mds.MdsIpException, mds.TreeFOPENR, mds.TdiMISS_ARG) as e: logger.warning('Random MDSplus error in get_current_shot') return except ValueError as e: logger.warning('ValueError in get_current_shot') return
def __init__(self, *args, **kwargs): super(MDSPlusAcquisition, self).__init__(*args, **kwargs) self.server_mode = None if hasattr(self, 'server'): if self.server.startswith('http'): self.server_mode = 'http' else: self.connection = MDSplus.Connection(self.server) self.server_mode = 'mds' for attr_name, attr_value in self.__dict__.items(): if attr_name.endswith('_path'): os.environ['%s' % (attr_name)] = attr_value
def __init__(self, stream, hostspec=_b._server): self._con = _mds.Connection(hostspec) if len(stream)>12: raise Exception('The name of the stream cannot be longer than 12 charaters. '+stream) self._stream = stream.upper() try: self._addNode() print('"'+self._stream+'" signal created.') except Exception as exc: sexc = str(exc) if sexc.startswith('%TREE-W-ALREADY_THERE'): print('"'+self._stream+'" signal found.') elif sexc.startswith('%TREE-E-FOPENW'): raise(Exception('"'+self._tree+'" tree not found.')) else: raise exc
def latestShotNumber(serverAddress=_settings._SERVER_ADDRESS, port=_settings._SERVER_PORT): """ Gets the latest shot number from the tree Parameters ---------- Returns ------- shot_num : int latest shot number """ conn = _mds.Connection('%s:%d' % (serverAddress, port)) shot_num = conn.get('current_shot("hbtep2")') return int(shot_num)
def __init__(self, shot, tree, server): """ Parameters ---------- shot : int Shot number. tree : str MDSplus tree name. server : str Address of the MDSplus server """ self.shot = shot self.tree = tree self.server = server self._conn = mds.Connection(server) self._conn.openTree(tree, shot)
def read_mds(host, tree, shot, signals=None): """ Connect to host and read the signals from the MDS tree of the specified shot. """ assert isinstance(host, str) assert isinstance(tree, str) assert isinstance(shot, int) signals = signals if signals else _SIGNALS conn = mds.Connection(host) conn.openTree(tree, shot) darrays = {} for signal in signals: darrays[_name(signal)] = _read_one_signal(conn, signal) conn.closeTree(tree, shot) return xray.Dataset(darrays)
def read_channel(self, chan, save_locally=1): """Try to read bin data from the channel specified, first locally, then from MDSPlus""" # dict to exchange between number and name of channel. channels = {1: 'K', 2: 'Ka', 3: 'ref', 4: 'time'} bands = {'K': 1, 'Ka': 2, 'ref': 3, 'time': 4} try: channel = channels[chan] except KeyError: channel = chan chan = bands[channel] if (chan == 4) & (self.mode == "ff"): print("no channel 4, data for fixed frequency shots") return try: self.arq = path.join(self.shot_folder, '%s_%s.bin' % (self.shot, chan)) self.bindata[channel] = np.fromfile(self.arq, np.int16) print("binary file: %s\n#Samples: %s" % (self.arq, len(self.bindata[channel]))) except IOError: print("no local data, connecting to MDSPlus") signals = { 1: '\\KBAND.SIGNAL', 2: '\\KABAND.SIGNAL', 3: '\\MIRNOV.SIGNAL', 4: '\\TRIGGER.SIGNAL' } try: # Local MDSplus Server tree = mds.Tree('tcabr_ref', self.shot) self.bindata[channel] = tree.getNode(signals[chan]).data() except: # External MDSplus Server conn = mds.Connection('tcabrcl.if.usp.br') conn.openTree('tcabr_ref', self.shot) self.bindata[channel] = np.array(conn.get(signals[chan])) conn.closeAllTrees() if save_locally == 1: self.save_channel(chan) self.save_info_file() self.datasize = len(self.bindata[channel])
def get_connection(shot, tree='mst'): """Get an MDSplus connection object connected to the appropriate server and having the given tree and shot opened. """ svr = get_server_for_shot(shot) conn, tree_, shot_ = _get_svr_cached(svr) if conn is None: conn = mds.Connection(svr) if tree != tree_ or shot != shot_: try: # This throws an exception if there are no open trees. conn.closeAllTrees() except: pass conn.openTree(tree, shot) _update_svr_cache(svr, conn, tree, shot) return conn
def getIpMeas(self): """returns magnetics-measured plasma current. Returns: IpMeas (Array): [nt] array of measured plasma current. Raises: ValueError: if module cannot retrieve data from MDS tree. """ if self._IpMeas is None: try: conn = MDSplus.Connection('tcvdata.epfl.ch') conn.openTree('tcv_shot', self._shot) ip = conn.get('tcv_ip()').data() ipTime = conn.get('dim_of(tcv_ip())').data() conn.closeTree(self._tree, self._shot) self._IpMeas = scipy.interp(self.getTimeBase(), ipTime, ip) self._defaultUnits['_IpMeas'] = 'A' except: raise ValueError('data retrieval failed.') return self._IpMeas.copy()
def getRsep(startTime=2500, endTime=5000, server='atlas.gat.com'): MDSplusCONN = mds.Connection(server) # Lines from Zeke's code. parmDICT = loadg.read_g_file_mds(shot, time, connection=MDSplusCONN, write2file=False) Rs, Zs = np.meshgrid(parmDICT['R'], parmDICT['Z']) Zes = np.copy(parmDICT['lcfs'][:, 1][13:-12]) Res = np.copy(parmDICT['lcfs'][:, 0][13:-12]) f_Rs = scinter.interp1d(Zes, Res, assume_sorted=False) # R_Sep for each z location of the three probes. rSep = {} rSep['a'] = f_Rs(-0.18) rSep['b'] = f_Rs(-0.1546) rSep['c'] = f_Rs(-0.2054) print "Rsep: " + str(rSep['a'])
def avg_ped(shot, tmin, tmax): conn = mds.Connection('localhost') def get_avg(tag): ped_obj = gadata(tag, shot, connection=conn) min_idx = np.where(ped_obj.xdata > tmin)[0].min() max_idx = np.where(ped_obj.xdata < tmax)[0].max() avg_ped = ped_obj.zdata[min_idx:max_idx].mean() return avg_ped avg_neped = get_avg('prmtan_neped') avg_teped = get_avg('prmtan_teped') avg_peped = get_avg('prmtan_peped') avg_tribot = get_avg('tribot') avg_tritop = get_avg('tritop') #avg_gasa = get_avg('gasa') print('ne ped: {:.3e}'.format(avg_neped)) print('Te ped: {:.3f}'.format(avg_teped)) print('Pe ped: {:.3f}'.format(avg_peped)) print('Min. tri: {:.3f}'.format(min(avg_tribot, avg_tritop)))
def _initRemoteMDSConnection(shotno, serverAddress=_settings._SERVER_ADDRESS, port=_settings._SERVER_PORT): """ Initiate remote connection with MDSplus HBT-EP tree Parameters ---------- shotno : int The shotnumber to store the data serverAddress : str The network/internet address of the server port : int The port of the server Returns ------- conn : MDSplus.connection connection class to mdsplus tree on the server for the specific shotno """ conn = _mds.Connection('%s:%d' % (serverAddress, port)) conn.openTree('hbtep2', int(shotno)) return conn