Mfxdod Old

mfxDOD_old

Classes

MicroToNano

MicroToNano()

Source code in dod/mfxDOD_old.py

def __init__(self):
    self._offset_nano = 0

Functions

__call__

__call__(micro)

Source code in dod/mfxDOD_old.py

def __call__(self, micro):
    return (micro * 1000) + self._offset_nano

getOffset_nano

getOffset_nano()

Source code in dod/mfxDOD_old.py

def getOffset_nano(self):
    return self._offset_nano

setOffset_micro

setOffset_micro(offset)

Source code in dod/mfxDOD_old.py

def setOffset_micro(self, offset):
    self._offset_nano = offset * 1000

setOffset_nano

setOffset_nano(offset)

Source code in dod/mfxDOD_old.py

def setOffset_nano(self, offset):
    self._offset_nano = offset

User

User()

Source code in dod/mfxDOD_old.py

    def __init__(self):

#        with safe_load ('VH_motors'):
#            self.vh_y = IMS('XCS:USR:MMS:02', name='vh_y')
#            self.vh_x = IMS('XCS:USR:MMS:03', name='vh_x')

#        with safe_load('Von Hamos Beckhoff'):
#            from pcdsdevices.epics_motor import BeckhoffAxis
#            class VonHamos_Spec(Device):
#                cr1_move = Cpt(BeckhoffAxis, ':01', name='cr1_move')
#                cr2_move = Cpt(BeckhoffAxis, ':02', name='cr2_move')
#                cr3_move = Cpt(BeckhoffAxis, ':03', name='cr3_move')
#                cr4_move = Cpt(BeckhoffAxis, ':04', name='cr4_move')
#                cr1_rot = Cpt(BeckhoffAxis, ':01', name='cr1_rot')
#                cr2_rot = Cpt(BeckhoffAxis, ':02', name='cr2_rot')
#                cr3_rot = Cpt(BeckhoffAxis, ':03', name='cr3_rot')
#                cr4_rot = Cpt(BeckhoffAxis, ':04', name='cr4_rot')
#            self.vhs = VonHamos_Spec('MFX:VHS:MMB', name='vhs')

        with safe_load ('LED'):
            #self.led = Trigger('XCS:R42:EVR:01:TRIG6', name='led_delay')
            self.led = Trigger('MFX:LAS:EVR:01:TRIG3', name='led_delay')
            #self.led = Trigger('XCS:R44:EVR:44:TRIG6', name='led_delay')
            self.led_uS = MicroToNano()

Attributes

led instance-attribute

led = Trigger('MFX:LAS:EVR:01:TRIG3', name='led_delay')

led_uS instance-attribute

led_uS = MicroToNano()

logger class-attribute instance-attribute

logger = getLogger(__name__)

post_template class-attribute instance-attribute

post_template = '    Run Number: {} {}\n\n    Acquiring {} events\n\n    {}\n    '

post_template_escan class-attribute instance-attribute

post_template_escan = '    Run Number: {} {}\n\n    {}\n    Minimum photon_energy -> {}\n    Maximum photon_energy -> {}\n    '

Functions

cleanup_RE

cleanup_RE()

Source code in dod/mfxDOD_old.py

def cleanup_RE(self):
    if not RE.state.is_idle:
        print('Cleaning up RunEngine')
        print('Stopping previous run')
        try:
            RE.stop()
        except Exception:
            pass

dummy_daq_test

dummy_daq_test(events=360, sleep=3, record=False)

Source code in dod/mfxDOD_old.py

def dummy_daq_test(self, events=360, sleep=3, record=False):
    daq.connect()
    while 1:
        daq.begin(events=events, record=record)
        daq.wait()
        daq.end_run()
        time.sleep(sleep)
        print(time.ctime(time.time()))
    return

led_scan

led_scan(start, end, nsteps, duration)

Function to scan led delays and dwell at each delay. Goes back to original delay after scanning.

Parameters:

Name	Type	Description	Default
start	float	Start delay in microseconds.	required
end	float	End delay in microseconds.	required
nsteps	integer	number of steps for delay.	required
duration	float	Dwell time at each delay. In seconds.	required

Source code in dod/mfxDOD_old.py

def led_scan(self, start, end, nsteps, duration):
    """
    Function to scan led delays and dwell at each delay. Goes back to original delay after scanning.

    Parameters
    ---------
    start : float
        Start delay in microseconds.
    end : float
        End delay in microseconds.
    nsteps : integer
        number of steps for delay.
    duration : float
        Dwell time at each delay. In seconds.
    """
    old_led = self.led.ns_delay.get()
    print('Scanning LED delays...')
    steps = np.linspace(start * 1000.0, end * 1000.0, nsteps)
    for step in steps:
        self.led.ns_delay.put(step)
        time.sleep(duration)
    self.led.ns_delay.put(old_led)
    print('Scan complete setting delay back to old value: ' +str(old_led))

listscan

listscan(motor, posList, nEvents, record=True, use_l3t=False)

Source code in dod/mfxDOD_old.py

def listscan(self, motor, posList, nEvents, record=True, use_l3t=False):
    self.cleanup_RE()
    currPos = motor.wm()
    daq.configure(nEvents, record=record, controls=[motor], use_l3t=use_l3t)
    try:
        RE(list_scan([daq], motor, posList))
    except Exception:
        logger.debug('RE Exit', exc_info=True)
    finally:
        self.cleanup_RE()
    motor.mv(currPos)

lxt_fast_set_absolute_zero

lxt_fast_set_absolute_zero()

Source code in dod/mfxDOD_old.py

def lxt_fast_set_absolute_zero(self):
    currentpos = lxt_fast()
    lxt_fast1_enc = UsDigitalUsbEncoder('MFX:USDUSB4:01:CH0', name='lxt_fast_enc1', linked_axis=lxt_fast)
    currentenc = lxt_fast_enc.get()
    #elog.post('Set current stage position {}, encoder value {} to 0'.format(currentpos,currentenc.pos))
    print('Set current stage position {}, encoder value {} to 0'.format(currentpos,currentenc.pos))
    lxt_fast.set_current_position(0)
    lxt_fast_enc.set_zero()
    return

perform_run

perform_run(events, record=True, comment='', post=True, **kwargs)

Perform a single run of the experiment

Parameters:

Name	Type	Description	Default
events		Number of events to include in run	required
record		Whether to record the run	True
comment	str	Comment for ELog	''
post		Whether to post to the experimental ELog or not. Will not post if not recording	True

Note

Source code in dod/mfxDOD_old.py

def perform_run(self, events, record=True, comment='', post=True,
                **kwargs):
    """
    Perform a single run of the experiment

    Parameters
    ----------
    events: int
        Number of events to include in run

    record: bool, optional
        Whether to record the run

    comment : str, optional
        Comment for ELog

    post: bool, optional
        Whether to post to the experimental ELog or not. Will not post if
        not recording

    Note
    ----
    """

    comment = comment or ''
    # Start recording
    logger.info("Starting DAQ run, -> record=%s", record)
    daq.begin(events=events, record=record)
    time.sleep(1)
    # Post to ELog if desired
    runnum = daq._control.runnumber()
    info = [runnum, comment, events, self._delaystr]
    post_msg = post_template.format(*info)
    print(post_msg)
    if post and record:
        elog(msg=post_msg, run=runnum)

    # Wait for the DAQ to finish
    logger.info("Waiting or DAQ to complete %s events ...", events)
    daq.wait()
    logger.info("Run complete!")
    daq.end_run()
    time.sleep(0.5)
    return

pvascan

pvascan(motor, start, end, nsteps, nEvents, record=None)

Source code in dod/mfxDOD_old.py

def pvascan(self, motor, start, end, nsteps, nEvents, record=None):
    currPos = motor.get()
    daq.configure(nEvents, record=record, controls=[motor])
    RE(scan([daq], motor, start, end, nsteps))
    motor.put(currPos)

pvdscan

pvdscan(motor, start, end, nsteps, nEvents, record=None)

Source code in dod/mfxDOD_old.py

def pvdscan(self, motor, start, end, nsteps, nEvents, record=None):
    daq.configure(nEvents, record=record, controls=[motor])
    currPos = motor.get()
    RE(scan([daq], motor, currPos + start, currPos + end, nsteps))
    motor.put(currPos)

scanExamples

scanExamples()

Source code in dod/mfxDOD_old.py

def scanExamples(self):
    print("""
    Absolute Scan
      re.daq_ascan([], sim.fast_motor1, -1, 1, 21, events = 10, record = False)

    Absolute 2D Scan
      re.daq_a2scan([], sim.fast_motor1, -1, 1 , sim.fast_motor2, -1, 1, nsteps = 5, events = 10, record = False)

    Absolute 3D Scan
      re.daq_a3scan([], sim.fast_motor1, -1, 1 , sim.fast_motor2, -1, 1, sim.fast_motor3, -1, 1, nsteps = 5, events = 10, record = False)

    Delta Scan
      re.daq_dscan([], sim.fast_motor1, -1, 1, 21, events = 10, record = False)

    Delay Scan
      re.daq_delay_scan([], lxt_fast, [-1e-12, 1e-12], sweep_time = 5,  duration = 20, record = False)

    Empty Delay Scan (no Daq)
      re.delay_scan([], lxt_fast, [-1e-12,1e-12], sweep_time = 5,  duration = 20)
    """)

set_current_position

set_current_position(motor, value)

Source code in dod/mfxDOD_old.py

def set_current_position(self, motor, value):
    motor.set_use_switch.put(1)
    motor.set_use_switch.wait_for_connection()
    motor.user_setpoint.put(value, force=True)
    motor.user_setpoint.wait_for_connection()
    motor.set_use_switch.put(0)

takeRun

takeRun(nEvents=None, duration=None, record=True, use_l3t=False)

Source code in dod/mfxDOD_old.py

def takeRun(self, nEvents=None, duration=None, record=True, use_l3t=False):
    daq.configure(events=120, record=record, use_l3t=use_l3t)
    daq.begin(events=nEvents, duration=duration)
    daq.wait()
    daq.end_run()