def __setGainN(self, igain, num):
"""
Set ipimb gain as an integer index in the enum.
Return True if args were ok, False otherwise.
"""
if (not isinstance(num, int)):
print 'channel number should be an integer!'
return False
currgain = self.__getGainN(num)
if currgain is None:
return False
if (igain == -1):
igain = currgain - 1
elif (igain == 101):
igain = currgain + 1
if igain < self.__minGain:
igain = self.__minGain
elif igain >= self.__maxGain:
igain = self.__maxGain - 1
if 0 <= num <= 3:
gain_str = self.__gainPV + str(num)
else:
print 'invalid channel # %f, wont set gain' % num
return False
Pv.put(gain_str, igain)
return True
def switch(self):
""" switches illuminator """
onoff = Pv.get(self.pv_OnOff)
if onoff == 1:
Pv.put(self.pv_OnOff, 1)
elif onoff == 0:
Pv.put(self.pv_OnOff, 0)
def set_testburst_rate(self, rate):
if not (rate in self.__dictRateToEnum):
print "!! Rate should be one of:",
print self.__dictRateToEnum.keys()
else:
Pv.put("PATT:SYS0:1:TESTBURST.N", 0)
Pv.put("PATT:SYS0:1:TESTBURSTRATE", self.__dictRateToEnum[rate])
def __move(self,pos):
Pv.put(self.__pvbase+":GO",0)
Pv.put(self.__pvbase+":STOP",1)
Pv.put(self.__pvbase+":CTRL_POS",int(pos*1.0e6/self.__getstepsize()))
Pv.put(self.__pvbase+":GO",1)
Pv.put(self.__pvbase+":STOP",0)
pass
def __setDelay(self, delay):
if (delay > self.__maxDelay or delay < self.__minDelay):
print ' the requested delay has to be between %s and %s' % (
self.__minDelay, self.__maxDelay)
print ' leave delay at ', self.__getDelay
return
Pv.put(self.__delayPV, delay)
def __theta_movement(self, theta):
x1, x2, z = ThetaToMotors(theta)
z_now = self.z.wm()
try:
if z_now < z:
print 'moving z to %+4.f' % z
self.z.mv(z)
self.z.wait()
print 'moving x1 to %+4.f and x2 to %.4f\n' % (x1, x2)
self.x1.mv(x1)
self.x2.mv(x2)
self.waitAll()
else:
print 'moving x1 to %+4.f and x2 to %.4f\n' % (x1, x2)
self.x1.mv(x1)
self.x2.mv(x2)
self.x1.wait()
self.x2.wait()
print 'moving z to %+4.f' % z
self.z.mv(z)
self.waitAll()
except KeyboardInterrupt:
self.stop()
finally:
Pv.put(self._theta_pv, self.wmTheta())
def __init__(self,name,pv_base,pv_TTL,Vlow=0,Vhigh=5): self.name = name self.pv_base = pv_base self.pv_TTL = pv_TTL self.Vhigh = Vhigh self.Vlow = Vlow Pv.put(pv_base,5) Pv.put(pv_TTL,0)
def close(self, fast=False):
""" close the shutter; the option fast when enable skip the test
that makes sure that the output is not triggered by any event code"""
#if (not fast):
#self.evr.disableAllEvents()
#self.evr.polarity(not self.__polarity)
self._cleanup()
Pv.put(self._PVname('S_CLOSE'), 1)
def __setBias(self, bias):
#fix this, unprotexted now
if (bias > self.__maxBias or bias < self.__minBias):
print ' the requested bias has to be between %s and %s' % (
self.__minBias, self.__maxBias)
print ' leave bias at ', self.__getBias()
return
Pv.put(self.__biasPV, bias)
def set_fburst(self, f="Full"):
f.replace(" ", "")
# remove spaces
if not (f in self.__freqs):
print "!! Frequency should be one of:",
print self.__freqs.keys()
else:
Pv.put("PATT:SYS0:1:MPSBURSTRATE", self.__freqs[f])
def speed(self,value=None):
if (value is not None):
Pv.put(self.speed_pv,value)
if (self.speed_rbv is None):
s=Pv.get(self.speed_pv)
else:
s=Pv.get(self.speed_rbv)
return s
def moveDSPhi(self, phi):
""" Move physical motors in sample/detector stages to get Phi reflection geometry """
if not self.assertLimitsDSPhi(phi):
return
self.reflectdet.move_silent(phi)
self.phi.move_silent(phi)
if self.pvBase is not None:
Pv.put(self.pvBase + ":GON:REF",phi)
pass
def moveEwithVernier(self, E, vernierThresKeV=.003):
""" E in keV """
if (E > 2000):
E = E / 1e3
Ever0 = Pv.get(self.__vernierPV) / 1000.
if n.abs(Ever0 - E) > vernierThresKeV:
Pv.put(self.__vernierPV, E * 1000)
alio = EToAlio(E)
self.alio.move(alio)
def gain(self,value=None):
''' Reads or changes gain in the PD feedback loop
usage: gain(): reads back current gain
gain(value): sets gain to passed value
'''
if (value is None):
return Pv.get(self.__pv_gain)
else:
Pv.put(self.__pv_gain,value)
def move(self, position):
if position in self.__positionMap:
curpos = self.__getPosition()
if curpos == positoin:
print "WARNING: Stopper is already %s\n" % (position)
else:
Pv.put(self.__getPV(self.__cmdPV), position)
else:
print "ERROR: '%s' is not a valid position, please use one of: %s\n" % (
position, __positionMap.keys())
def disableAllEventsForGivenTrigger(self, trigger):
""" Disable all events code for a give trigger """
if (trigger > self.__ntriggers - 1):
print "in disableAllEventsForGivenTrigger you asked for a trigger that is not defined ... exiting"
return 0
for i in range(self.__nevent_numbers):
names = self.__getpvnames(i + 1)
# starts with 1 and not zero
Pv.put(names[trigger], 0)
return 1
def trip(self, value=None):
""" Sets or Returns the gauge trip point for the vacuum PLC """
previous_trip = Pv.get(self.__pstatsprbck)
if (value is not None):
Pv.put(self.__pstatspdes, value)
s = "Resetting PLC trip point of `%s` from %.4g to %.4g" % (
self.name, previous_trip, value)
logprint(s, print_screen=True)
else:
print "%s trip point is %.4g" % (self.name, previous_trip)
def set(self, value):
if (self._set is not None):
self._set(value)
elif (self.pvoff is not None):
offset = value - self.direction * self.wm_dial()
Pv.put(self.pvoff, offset)
sleep(0.1)
# gives epics time to update offset pv
self.wm()
else:
print "user position not defined for this motor"
def speed(self,value=None):
"""returns the speed, or sets it.
This is a temporary hack, particularly for the nanoc for the tychography
"""
if value==None:
v=Pv.get(self.pvspeed)
return v
else:
Pv.put(self.pvspeed,str(value))
def __init__(self):
self.howto()
#self.elog = pypsElog.pypsElog()
for pv, item in self._pvs.items():
print 'Adding ', pv, item
item['Pv'] = Pv.Pv(item['pv'])
setattr(self, pv, item['default'])
Pv.put(item['pv'] + '.DESC', item['desc'])
self.EXP = 'current'
self.run()
def fixSN(pmgr, PV):
pv.put(PV + ".RINI", 1) # Re-initialize motor to get accurate SN
objID = objFromPV(pmgr, PV)
pmgr.updateTables()
d = pmgr.objs[objID]
# Set up Pv object so we can specify a timeout and wait for init.
SNPV = pv.Pv(PV + ".SN")
SNPV.connect(timeout=5)
SN = SNPV.get() # Pull the value we need
SNPV.disconnect()
d["FLD_SN"] = SN
transaction(pmgr, "objectChange", objID, d)
def fixSN(pmgr, PV):
pv.put(PV + ".RINI", 1) # Re-initialize motor to get accurate SN
objID = objFromPV(pmgr, PV)
pmgr.updateTables()
d = pmgr.objs[objID]
# Set up Pv object so we can specify a timeout and wait for init.
SNPV = pv.Pv(PV + ".SN")
SNPV.connect(timeout=5)
SN = SNPV.get() # Pull the value we need
SNPV.disconnect()
d["FLD_SN"] = SN
transaction(pmgr, "objectChange", objID, d)
def moveDetPhi(self, phi):
""" Move Detector to phi reflection (2*phi). This requires translating det-y and rotating det-gamma """
self.checkDetPhiConfig()
if not self.assertLimitsDetPhi(phi):
return
tphi = 2. * phi
y_off = -1. * self.detCenOffset * math.tan(tphi*math.pi/180.)
print "moving gam,dy to %f,%f" % (tphi,y_off)
self.gam.move_silent(tphi)
self.dy.move_silent(y_off)
if self.pvBase is not None:
Pv.put(self.pvBase + ":GON:REFD",phi)
pass
def level(self, level='status'):
"""changes illumination level"""
if level is "status":
volt = Pv.get(self.pv_Volt)
level = (volt - self.Vlow) / (self.Vhigh - self.Vlow)
return level
else:
level = float(level)
if level > 1:
level = level / 100.
print 'Illuminator Level was interpreted as percent'
levelinvolt = self.Vlow + level * (self.Vhigh - self.Vlow)
Pv.put(self.pv_Volt, levelinvolt)
def moveEn(self, energy):
""" Move Energy to value -> Analyzer crystal to according theta, detector to 2theta """
self.energy = energy
th = self.convertEnergyToAngle(energy)
if th is not None and self.assertLimitsEn(energy):
print "moving th, tth to %f,%f" % (th, 2 * th)
self.ath.move_silent(th)
self.atth.move_silent(2 * th)
if self.pvBase is not None:
#print "putting energy"
Pv.put(self.pvBase + ":Analyzer_Energy", energy)
pass
pass
def delay(self, value=None):
'''return the current delay of the X-rays with respect to laser if value is None.
If a value is passed, the delay is change to that value. All values in seconds.
'''
if value == None:
delay_value = self.get_offset() - self.dial_delay()
if self._delay_pv_name != None:
Pv.put(self._delay_pv_name, delay_value)
return delay_value
else:
self.dial_delay(self.get_offset() - value)
if self._delay_pv_name != None:
Pv.put(self._delay_pv_name, value)
def dial_delay(self, value=None):
'''return the current delay if value is None.
If a value is passed, the delay is change to that value. All values in seconds.
The returned values are those directly read of the DG645, without offset taken into
account.
'''
if value == None:
delay_read = Pv.get(self._pvbase + 'DelaySI')
return double(delay_read[5:])
elif self._low_lim < value < self._high_lim:
Pv.put(self._pvbase + 'DelayAO', value)
else:
print('Delay outside of allowed range')
def setDefaultsForTrigger(self, trigger):
""" Set EVR defaults for a given trigger (including mapping trigger#i->out#i"""
self.EVReventCode.setDefaultsForTrigger(trigger)
Pv.put(self.ioc + ":CTRL.ENAB", 1)
#enable card
self.assignOutToTrigger(trigger, trigger)
# assign out #i to trigger #i
self.change("enable", 1, trigger)
# enable trigger #i
self.change("polarity", 0, trigger)
# polarity normal for trigger #i
self.change("prescale", 1, trigger)
# default prescaler for trigger #i
self.setWidth(1e-3, trigger)
self.setDelay(1e-3, trigger)
def wm(self, debug=0):
if debug > 0:
print 'virt motor wm: '
if (self.pvoff is None):
offset = 0
else:
offset = Pv.get(self.pvoff)
if debug > 0:
print 'virtualmotor offset: ', offset
print 'virtualmotor dir: ', self.direction
print 'virtualmotor dial pos: ', self.wm_dial()
user = self.direction * self.wm_dial() + offset
if (self.pvpos is not None):
Pv.put(self.pvpos, user)
return user
def setDefaults(self):
self.EVReventCode.setDefaults()
Pv.put(self.ioc + ":CTRL.ENAB", 1)
#enable card
for i in range(self.__ntriggers):
self.assignOutToTrigger(i, i)
# assign out #i to trigger #i
for i in range(self.__ntriggers):
self.change("enable", 1, i)
# enable trigger #i
self.change("polarity", 0, i)
# polarity normal for trigger #i
self.change("prescale", 1, i)
# default prescaler for trigger #i
self.setWidth(1e-3, i)
self.setDelay(1e-3, i)
def __move(self, pos):
ll = self.get_lowlim()
lh = self.get_hilim()
if (pos < ll):
print "ERROR: Commanded position (%.3f) exceeds low soft-limit (%.3f)" % (
pos, ll)
pass
elif (pos > lh):
print "ERROR: Commanded position (%.3f) exceeds high soft-limit (%.3f)" % (
pos, lh)
pass
else:
Pv.put(self.pvname, pos)
self.__commanded_position = pos
pass
pass
