egaltier
commented
4 years ago File ns_timing.py from old mecpython:
import pypsepics
from numpy import *
from time import sleep
from utilities import estr
class NS_Timing(object):
''' Class that defines a timing channel of a DG645 delay generator.
It uses an epics PV that is the value of the offset, so that timings
can be given with respect to a reference. For example, the ns laser
timing would be specified with respect to a t0, which is when the
of the laser and the x-rays coincide.
Since most users think of delaying the X-rays with respect to the
laser, positive delays pull the laser trigger earlier.
So:
The offset is the value on the DG645 box that corresponds to zero delay
The delay = offset - Value_on_DG645
The delay is also written to an epics pv whenever it is written or read
'''
def __init__(self,channel_pvbase='MEC:LAS:DDG:03:e',high_lim=1.0,low_lim=0.0,offset_pv_name='MEC:NOTE:LAS:NST0',delay_pv_name=None,name='nstiming'):
self._name=name
self._pvbase=channel_pvbase
self._low_lim=low_lim
self._high_lim=high_lim
self._offset_pv_name=offset_pv_name
self._delay_pv_name=delay_pv_name #epics variable that hold the current delay. It is updated whenever a delay is written or read by .delay()
def __call__(self,value=None):
'''if instance is called with no atribute, it gives back or put the value inthe delay:
usage: nstiming() : reads back current delay
nstiming(value): puts value in delay
'''
return self.delay(value)
def get_offset(self):
'''returns the value of the offset'''
return pypsepics.get(self._offset_pv_name)
def set_offset(self,value):
'''writes the value to the PV that holds the offset value'''
pypsepics.put(self._offset_pv_name,value)
def wait(self):
'''waits 0.1s, such that the DG645 is updated before continuing the script'''
sleep(0.1)
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=pypsepics.get(self._pvbase+'DelaySI')
return double(delay_read[5:])
elif self._low_lim < value < self._high_lim:
pypsepics.put(self._pvbase+'DelayAO',value)
else: print('Delay outside of allowed range')
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:
pypsepics.put(self._delay_pv_name,delay_value)
return delay_value
else:
self.dial_delay(self.get_offset() - value)
if self._delay_pv_name!=None:
pypsepics.put(self._delay_pv_name,value)
def status(self):
'''return a string that formats the delay and t0 '''
retstr='Nanosecond laser : '
delay=self.delay()
if not (-5e-9 < delay < 50e-9):
color='red'
type='bold'
else:
color='black'
type='normal'
retstr+=estr('Delay = ' + str(delay) +'\n',color=color,type=type)
retstr+=estr(' T0 = ' + str(self.get_offset()) +'\n',color=color,type=type)
return retstr
def redefine_delay(self,value=0.0):
'''redifine the current value of the delay generator as the delay given by
the value. The value is standard 0.
usage: redefine_delay(): the current setting of the delay generator correspond to t0
redefine_delay(4e-9): the current setting of the delay generator correspond to a delay of 4ns
'''
self.set_offset(self.dial_delay()+value)
def mvr(self,value):
"""Moves the delay 'value' reltive the current delay"""
old_delay=self.delay()
new_delay=old_delay+value
self.delay(new_delay)
slactjohnson
Feature Request
Define functions to delay the X-ray pulse vs an optical laser before interacting with a sample.
Existing Alternatives
I did not find any similar functions in the current mecpython version. The alternative is set several DG645 boxe's channels or VITARA target time manually, everytime that a different time is required. Incorrect values can be potentially set which could be detrimental to the laser systems (the VITARA could go out of range and pose issues for locking, bucket could be jumped for long pulse laser sysems, ...).
Context
While this request is linked to MEC, some of the functions are relevant for short pulse duration laser systems available in the other hutches. At MEC, we have a long pulse laser system whose delay vs the LCLS is achieved by changing delays on channels of an SRS box, and a short pulse laser system whose delay vs the LCLS is achieved by changing the target time of the VITARA. Changing timing in these devices is risky so controlling it by the use of a script helps to secure safe operation by the staff or the users. In the past, similar type of functions have been developed (old versions as
*.pyfiles are attached to this issue) but are now missing in the new hutch python implementation.Suggestions There should be two types of function implemented, as a function of the laser system in use:
where
splstands for short pulse laser (a short pulse duration is ps or fs) andlplstands for long pulse laser (a long pulse duration is ns). From the user perspective, it makes more sense to start naming these functions byxray_delaysince in a pump-probe experiment at an FEL, the FEL is usually used as a probe with the optical laser used to excite the sample (whether it is used in bio, condensed material or high energy density science). Of course, we know that the X-ray arrival time on sample cannot be changed and that we actually change the optical laser timing. But in a python implementation, this should be transparent to users to avoid confusion.Each function should have a set of common attribute like:
Each of these attributes are important for the operation, here are their description and common use:
delay is
negativethe X-rays arrive before the optical laser. So, if one enteredxray_delay_vs_spl(300e-15), the delay text could read:def set_t0(self, val):
def mvr(self):
def xray_delay_vs_spl(self, val):