def store(self): event_name = self.data_event.data() if self.t2.rlength == 0: self.t2.record = MDSplus.Int64(time.time() * 1000.) trend_tree = self.getTrendTree() trend_dev = trend_tree.getNode(self.trend_device.data()) # Getting T1 from TREND: t1 = MDSplus.Int64(self.t1.data() * 1000.) #Saving TREND shot number information into the tree: self.trend_shot.record = trend_tree.getCurrent(self.trend_tree.data()) #Set Time Context trend_tree.setTimeContext(t1, self.t2.data()) print('Writing data into shot node') for i in self.inputs(): trend_temp = trend_dev.__getattr__('input_%c' % (chr(i))) trend_resis = trend_dev.__getattr__('input_%c_resistence' % (chr(i))) times = trend_temp.dim_of().data() temps = trend_temp.data() resists = trend_resis.data() # Might be able to improve start_time = times[0] for j in range(len(times)): times[j] -= start_time times[j] = float(times[j]) / 1000. shot_temp = self.__getattr__('input_%c' % (chr(i))) shot_resis = self.__getattr__('input_%c_resistence' % (chr(i))) shot_temp.record = MDSplus.Signal(temps, None, times) shot_resis.record = MDSplus.Signal(resists, None, times) for i in self.loops(): trend_outpower = trend_dev.__getattr__('loop_%c' % (str(i + 1))) times = trend_outpower.dim_of().data() outpower = trend_outpower.data() start_time = times[0] for j in range(len(times)): times[j] -= start_time times[j] = float(times[j]) / 1000. shot_outpower = self.__getattr__('loop_%c' % (str(i + 1))) shot_outpower.record = MDSplus.Signal(outpower, None, times) MDSplus.Event.setevent(event_name)
def decompile(self): self.assertEqual(str(m.Uint8(123)), '123BU') self.assertEqual(str(m.Uint16(123)), '123WU') self.assertEqual(str(m.Uint32(123)), '123LU') self.assertEqual(str(m.Uint64(123)), '123QU') self.assertEqual(str(m.Int8(123)), '123B') self.assertEqual(str(m.Int16(123)), '123W') self.assertEqual(str(m.Int32(123)), '123') self.assertEqual(str(m.Int64(123)), '123Q') self.assertEqual( str(m.Signal(m.ZERO(100000, 0).evaluate(), None, 0)), "Build_Signal(Set_Range(100000,0 /*** etc. ***/), *, 0)")
def _dim(time, t0): if len(time): t0 = _mds.Int64(t0) time = _mds.Int64Array(time) if t0 == 0: unit = 'ns' else: time = _mds.Float64(time - t0) * 1E-9 unit = 's' wind = _mds.Window(time[0], time[time.shape[0] - 1], t0) dim = _mds.Dimension(wind, time) dim.setUnits(unit) return dim else: return _mds.EmptyData()
def run(self): def time_rel(ns=1e9): return MDSplus.DIVIDE(MDSplus.Int64(ns), self.frame_rate) try: cur_frame = 0 rng = MDSplus.Range(None, None, time_rel()) while True: try: queued = self.queue.get(True, 1) except queue.Empty: if self.strm.on: continue break # measurement done if queued is None: break trigger, frames = queued if self.fsttrig is None: self.fsttrig = trigger trigger = MDSplus.Int64(trigger - self.fsttrig) trg = MDSplus.ADD(self.trigger, trigger) first_frame = cur_frame for ic in range(frames.shape[0]): dim = MDSplus.ADD(trg, time_rel([cur_frame * 1e9])) limit = MDSplus.ADD(trg, time_rel(cur_frame * 1e9)) data = frames[ic:ic + 1] self.frames.makeSegment( limit, limit, dim, data) cur_frame += 1 last_frame = cur_frame - 1 win = MDSplus.Window(first_frame, last_frame, trg) start = MDSplus.ADD(trg, time_rel(first_frame * 1e9)) end = MDSplus.ADD(trg, time_rel(last_frame * 1e9)) dim = MDSplus.Dimension(win, rng) frames = frames.reshape( (frames.shape[0], -1)).max(1) self.frames_max.makeSegment( start, end, dim, frames) self.queue.task_done() except Exception as e: self.exception = e traceback.print_exc()
def run(self): while not self.stopped.wait(0.01): if (self.index == len(self.data) - 1): self.stopped.set() MDSplus.Event.stream(1, 'LIFT_COIL_DEMAND', MDSplus.Int64((time.time()) * 1000), MDSplus.Float64(self.data[self.index])) # data = json.dumps({u'absolute_time': 0, # u'shot': 1, # u'name': u'LIFT_COIL_DEMAND', # u'timestamp': int(time.time()), # u'times': [(time.time()-self.start_time)*1000], # u'seq_number': self.index, # u'samples': [self.data[self.index]]}) # print(data.__class__) # print(np.array(data)) # MDSplus.Event.setevent('LIFT_COIL_DEMAND',np.array(data)) self.index += 1
def trend(self): # start it trending self.running.on = True s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((str(self.node.data()), 5000)) # open the instrument if self.debugging(): print("about to open cryocon device %s" % str(self.node.data())) event_name = self.data_event.data() try: self.status_out.getData() except: if self.debugging(): print( "Status_Out tree node is empty. Lets write the data now.") # read and save the status commands status_out = {} for cmd in self.status_cmds: if self.debugging(): print('about to send %s' % cmd) # status_out[str(cmd)] = instrument.query(str(cmd)) status_out[str(cmd)] = self.queryCommand(s, str(cmd)) if self.debugging(): print(' got back %s' % status_out[str(cmd)]) self.status_out.record = status_out # Control Loop PID values Numeric Entry The Pgain, Igain and Dgain lines correspond to the Proportional, # Integral and Derivative coefficients of the control loop. Pman is the output power that will be applied # to the load if the manual control mode is selected. # Values for the Proportional, or P, gain term range from zero to 1000. This is a unit- less gain term # that is applied to the control loop. Gain is scaled to reflect the actual heater range and the load resistance. # Integrator gain values range from zero to 10,000. The units of this term are Seconds. A value of zero # turns the integration function off. # Derivative gain values have units of inverse Seconds and may have values from zero to 1000. A value of # zero turns the Derivative control function off. for i in self.loops(): # Proportional gain, or P term for PID control. # This is a numeric field that is a percent of full scale. pgain_chan = self.__getattr__('loop_%c_propor_gain' % (str(i + 1))) pgain_query_cmd = 'LOOP %c:PGA?' % (str(i + 1), ) # Integrator gain term, in Seconds, for PID control. # This is a numeric field that is a percent of full scale. igain_chan = self.__getattr__('loop_%c_integr_gain' % (str(i + 1))) igain_query_cmd = 'LOOP %c:IGA?' % (str(i + 1), ) # Derivative gain term, in inverse-Seconds, for PID control. # This is a numeric field that is a percent of full scale. dgain_chan = self.__getattr__('loop_%c_deriva_gain' % (str(i + 1))) dgain_query_cmd = 'LOOP %c:DGA?' % (str(i + 1), ) spoint_chan = self.__getattr__('loop_%c_setpoint' % (str(i + 1))) spoint_query_cmd = 'LOOP %c:SETP?' % (str(i + 1), ) ansQuery = self.queryCommand(s, pgain_query_cmd) try: pgain_chan.getData() igain_chan.getData() dgain_chan.getData() except: try: print("Parsing Proportional Gain /%s/" % ansQuery) pgain = float(ansQuery) except: if self.debugging(): print("Could not parse Proportional Gain /%s/" % ansQuery) pgain = 0.0 pgain_chan.record = MDSplus.Float32(pgain) ansQuery = self.queryCommand(s, igain_query_cmd) try: print("Parsing Integral Gain /%s/" % ansQuery) igain = float(ansQuery) except: if self.debugging(): print("Could not parse Integral Gain /%s/" % ansQuery) igain = 0.0 igain_chan.record = MDSplus.Float32(igain) ansQuery = self.queryCommand(s, dgain_query_cmd) try: print("Parsing Derivative Gain /%s/" % ansQuery) dgain = float(ansQuery) except: if self.debugging(): print("Could not parse Derivative Gain /%s/" % ansQuery) dgain = 0.0 dgain_chan.record = MDSplus.Float32(dgain) ansQuery = self.queryCommand(s, spoint_query_cmd) try: print("Parsing Setpoint /%s/" % ansQuery) spoint = float(ansQuery) except: if self.debugging(): print("Could not parse Setpoint /%s/" % ansQuery) spoint = 0.0 spoint_chan.record = MDSplus.Float32(spoint) for i in self.inputs(): t_chans = self.__getattr__('input_%c' % (chr(i))) r_chans = self.__getattr__('input_%c_resistence' % (chr(i))) if t_chans.on: query_cmd_temp = 'INP %c:TEMP?;SENP?' % (chr(i), ) ansQuery = self.queryCommand(s, query_cmd_temp) t_time = time.time() # Temperature reading try: temps = float(ansQuery.split(';')[0]) is_digit = True except ValueError: is_digit = False if self.debugging(): print("Could not parse temperature /%s/" % ansQuery.split(';')[0]) if not is_digit: temps = -9999.0 t_chans.putRow(1000, MDSplus.Float32(temps), MDSplus.Int64(t_time * 1000.)) # Resistence reading try: resists = float(ansQuery.split(';')[1]) is_digit = True except ValueError: is_digit = False if self.debugging(): print("Could not parse resist /%s/" % ansQuery.split(';')[1]) if not is_digit: resists = -9999.0 r_chans.putRow(1000, MDSplus.Float32(resists), MDSplus.Int64(t_time * 1000.)) for i in self.loops(): p_chans = self.__getattr__('loop_%c' % (str(i + 1))) query_cmd_outp = 'LOOP %c:HTRRead?' % (str(i + 1), ) ansQuery = self.queryCommand(s, query_cmd_outp) answerOutp = ansQuery[: -1] #remove the '%' at the end of the number if p_chans.on: t_time = time.time() # Output Power reading: Queries the output power of the selected control loop. # This is a numeric field that is a percent of full scale. try: print("Parsing output power /%s/" % ansQuery) if 'NAK' not in ansQuery: outpower = float(answerOutp) else: outpower = float(-9999.0) except ValueError: if self.debugging(): print("Could not parse output power /%s/" % ansQuery) p_chans.putRow(1000, MDSplus.Float32(outpower), MDSplus.Int64(t_time * 1000.)) MDSplus.Event.setevent(event_name) s.close()
def time_rel(ns=1e9): return MDSplus.DIVIDE(MDSplus.Int64(ns), self.frame_rate)
def trend(self): ''' trend method for cryocon18i record the values of the status commands start the stream STILL NEEDS TO STORE Calibration CURVES !! Store one sample for each of the channels that is on using putRow. The timestamp will be time since the unix EPOCH in msec ''' # start it trending self.running.on = True event_name = self.data_event.data() if self.debugging(): print("About to open cryocon device %s" % str(self.node.data())) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((str(self.node.data()), 5000)) try: self.status_out.getData() except: # read and save the status commands status_out = {} for cmd in self.status_cmds: if self.debugging(): print('about to send %s' % cmd) status_out[str(cmd)] = self.queryCommand(s, str(cmd)) if self.debugging(): print(' got back %s' % status_out[str(cmd)]) self.status_out.record = status_out # for i in range(ord('a'), ord('h')+1+1): # chan = self.__getattr__('input_%c'%(chr(i),)) # if chan.on: # cal = self.__getattr__('input_%c_calibration'%(chr(i),)) # ans = self.queryCommand(s, 'CALCUR %c?'%(chr(i))) # print(ans) # cal.record = ans #print(self.queryCommand(s, 'CALCUR')) query_cmd = '' ansQuery = [] for i in self.inputs: t_chan = self.__getattr__('input_%c' % (i, )) if t_chan.on: query_cmd = 'INP %c?;INP %c:SENP?;' % (i, i) ansQuery = self.queryCommand(s, query_cmd)[:-1].split(';') t_time = time.time() try: temp = float(ansQuery[0]) except: if self.debugging(): print("Could not parse temperature /%s/" % ansQuery[0]) temp = 0.0 t_chan.putRow(1000, MDSplus.Float32(temp), MDSplus.Int64(t_time * 1000.)) r_chan = self.__getattr__('input_%c_resistence' % (i, )) try: resist = float(ansQuery[1]) except: if self.debugging(): print("Could not parse resist /%s/" % ansQuery[1]) resist = 0.0 r_chan.putRow(1000, MDSplus.Float32(resist), MDSplus.Int64(t_time * 1000.)) MDSplus.Event.setevent(event_name) s.close()