def main():
for i in range(10000):
print "Acquire " + str(i)
error = False
caput("BL1A:CS:RunControl:Start", 1, wait=True, timeout=20)
status = caget("BL1A:CS:RunControl:StateEnum")
if (status != RC_RUN):
print "ERROR on Start: i= " + str(i) + \
" status= " + str(status) + " and it should be " + str(RC_RUN)
error = True
status = caget("BL1A:Det:N1:DetectorState_RBV")
if (status != AD_ACQUIRE):
print "ERROR on Start: i= " + str(i) + \
" BL1A:Det:N1:DetectorState_RBV= " + str(status) + " and it should be " + str(AD_ACQUIRE)
status_msg = caget("BL1A:Det:N1:StatusMessage_RBV")
print "ADnED Status message: " + str(status_msg)
error = True
if error:
cothread.Sleep(1)
status = caget("BL1A:Det:N1:DetectorState_RBV")
print "ADnED delayed status read: " + str(status)
sys.exit(1)
sleepTime = randint(1,10)
print "sleepTime: " + str(sleepTime)
cothread.Sleep(sleepTime)
caput("BL1A:CS:RunControl:Stop", 1, wait=True, timeout=20)
#cothread.Sleep(1) #At the moment callback not supported on a stop.
status = caget("BL1A:CS:RunControl:StateEnum")
if (status != RC_IDLE):
print "ERROR on Stop: i= " + str(i) + \
" status= " + str(status) + " and it should be " + str(RC_IDLE)
error = True
status = caget("BL1A:Det:N1:DetectorState_RBV")
if (status != AD_IDLE):
print "ERROR on Stop: i= " + str(i) + \
" BL1A:Det:N1:DetectorState_RBV= " + str(status) + " and it should be " + str(AD_IDLE)
status_msg = caget("BL1A:Det:N1:StatusMessage_RBV")
print "ADnED Status message: " + str(status_msg)
error = True
if error:
cothread.Sleep(1)
status = caget("BL1A:Det:N1:DetectorState_RBV")
print "ADnED delayed status read: " + str(status)
sys.exit(1)
def get_mr(self):
get_command = util.abstract_caget
beam_current_max_warning = False
# Only control injection if there are variables that require it.
if self.measurement_vars_inj:
# First measure the injection results
# Begin injecting
print "Start injection"
caput('LI-TI-MTGEN-01:START', 1)
cothread.Sleep(0.1)
caput('LI-TI-MTGEN-01:START', 0)
cothread.Sleep(4.0)
if self.beam_current_bounds[0] is not None:
beam_current = get_command('SR-DI-DCCT-01:SIGNAL')
while beam_current < self.beam_current_bounds[0]:
print 'waiting for beam current to rise above ', \
self.beam_current_bounds[0]
cothread.Sleep(1)
beam_current = get_command('SR-DI-DCCT-01:SIGNAL')
print '...'
mrs_inj = util.measure_results(self.measurement_vars_inj,
util.abstract_caget)
# Now for the non-injection measurements
if self.beam_current_bounds[1] is not None:
if get_command(
'SR-DI-DCCT-01:SIGNAL') > self.beam_current_bounds[1]:
beam_current_max_warning = True
# Stop injection
print "Stop injection"
caput('LI-TI-MTGEN-01:STOP', 1)
cothread.Sleep(0.1)
caput('LI-TI-MTGEN-01:STOP', 0)
cothread.Sleep(1)
else:
mrs_inj = []
mrs_noinj = util.measure_results(self.measurement_vars_noinj,
util.abstract_caget)
# Now combine the results into a single list
mrs = mrs_noinj + mrs_inj
if beam_current_max_warning:
msg = 'Beam current limit exceeded.\nDump the beam before pressing OK.'
tkMessageBox.showwarning('DUMP THE BEAM', msg)
return mrs
def test_multi(self):
l = [1]
def tick():
l.append(l[-1] + 2)
t = cothread.Timer(0.1, tick, retrigger=True)
self.assertEqual(l, [1])
cothread.Sleep(0.15)
self.assertEqual(l, [1, 3])
cothread.Sleep(0.1)
self.assertEqual(l, [1, 3, 5])
t.cancel()
cothread.Sleep(0.15)
self.assertEqual(l, [1, 3, 5])
def get_mr(self):
get_command = util.abstract_caget
beam_current_max_warning = False
# First measure the injection results
# Begin injecting
print "Start injection"
caput('LI-TI-MTGEN-01:START', 1)
cothread.Sleep(0.1)
caput('LI-TI-MTGEN-01:START', 0)
cothread.Sleep(4.0)
if self.beam_current_bounds is not None:
beam_current = get_command('SR-DI-DCCT-01:SIGNAL')
while beam_current < self.beam_current_bounds[0]:
print 'waiting for beam current to rise above ', \
self.beam_current_bounds[0]
cothread.Sleep(1)
beam_current = get_command('SR-DI-DCCT-01:SIGNAL')
print '...'
mrs_inj = util.measure_results(self.measurement_vars_inj,
util.abstract_caget)
# Now for the non-injection measurements
if self.beam_current_bounds is not None:
if get_command(
'SR-DI-DCCT-01:SIGNAL') > self.beam_current_bounds[1]:
beam_current_max_warning = True
# Stop injection
print "Stop injection"
caput('LI-TI-MTGEN-01:STOP', 1)
cothread.Sleep(0.1)
caput('LI-TI-MTGEN-01:STOP', 0)
cothread.Sleep(1)
mrs_noinj = util.measure_results(self.measurement_vars_noinj,
util.abstract_caget)
# Now combine the results into a single list
results = mrs_noinj + mrs_inj
mrs = results
return mrs
def main():
for i in range(100):
print "Acquire " + str(i)
det1_counts = caget("BL99:Det:N1:Det1:EventTotal_RBV")
det2_counts = caget("BL99:Det:N1:Det2:EventTotal_RBV")
print "det1_counts before: " + str(det1_counts)
print "det2_counts before: " + str(det2_counts)
caput("BL99:Det:N1:Start", 1, wait=True, timeout=5)
status = caget("BL99:Det:N1:DetectorState_RBV")
if (status != STAT_ACQUIRE):
print "ERROR on Start: i= " + str(i) + \
" status= " + str(status) + " and it should be " + str(STAT_ACQUIRE)
sys.exit(1)
det1_counts = caget("BL99:Det:N1:Det1:EventTotal_RBV")
det2_counts = caget("BL99:Det:N1:Det2:EventTotal_RBV")
print "det1_counts after: " + str(det1_counts)
print "det2_counts after: " + str(det2_counts)
cothread.Sleep(5)
caput("BL99:Det:N1:Stop", 1, wait=True, timeout=5)
status = caget("BL99:Det:N1:DetectorState_RBV")
if (status != STAT_IDLE):
print "ERROR on Stop: i= " + str(i) + \
" status= " + str(status) + " and it should be " + str(STAT_IDLE)
sys.exit(1)
def test_monitor(self):
self.assertIOCRunning()
longout = self.testprefix + 'longout'
values = []
def callback(value):
values.append(value)
m = catools.camonitor(longout, callback, notify_disconnect=True)
# Wait for connection
while not values:
cothread.Sleep(0.1)
catools.caput(longout, 43, wait=True)
catools.caput(longout, 44, wait=True)
self.iocStop()
# Can't call iocStop twice...
def iocStop():
return
self.iocStop = iocStop
m.close()
self.assertEqual(len(values), 4)
self.assertEqual(values[:3], [42, 43, 44])
self.assertEqual([v.ok for v in values], [True, True, True, False])
def do_go(self):
if caget(self.prefix + ":MOTOR.RBV") < 0.001:
self.go_countdown = 0
if self.go_countdown == 0:
try:
val = float(str(self.ui.D.text()))
except ValueError:
val = 10
self.ui.D.setText("10")
caput(self.prefix + ":GATHER:DEMAND", val)
tSample = caget(self.prefix + ":GATHER:TSAMPLE.B")
accl = caget(self.prefix + ":MOTOR.ACCL")
tMove = max(accl + (val / caget(self.prefix + ":MOTOR.VELO")),
2 * accl)
tMove = 2 * tMove + caget(self.prefix + ":GATHER:DELAY") + 0.5
sPeriod = int(tMove * 1000.0 / (1024.0 * tSample)) + 1
caput(self.prefix + ":GATHER:SPERIOD", sPeriod)
cothread.Sleep(0.2)
# timer tick in ms
tick = sPeriod * tSample * 10.24 + 30
self.timer = QtCore.QTimer()
self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.tick)
caput(self.prefix + ":GATHER:STATE", "EXECUTE")
caput(self.prefix + ":GATHER:EXECUTE", 1)
self.timer.start(tick)
self.go_countdown = 50
self.go_timer.stop()
else:
self.go_countdown -= 1
def worker(n):
for i in range(25):
print(f"{n}", end="")
if i == 6:
raise Exception(f"cothread {n} crashed!")
cothread.Sleep(random.random() * 0.5) # suspend cothread
print()
def get_mr(self):
global beam_current_bounds
get_command = abstract_caget
beam_current_max_warning = False
''' First measure the injection results '''
# Begin injecting
print "Start injection"
caput('LI-TI-MTGEN-01:START', 1)
cothread.Sleep(0.1)
caput('LI-TI-MTGEN-01:START', 0)
cothread.Sleep(4.0)
beam_current = get_command('SR-DI-DCCT-01:SIGNAL')
while beam_current < beam_current_bounds[0]:
print 'waiting for beam current to rise above ', beam_current_bounds[
0]
cothread.Sleep(1)
beam_current = get_command('SR-DI-DCCT-01:SIGNAL')
print '...'
run = True
start_time = time.time()
mrs_inj = measure_results(self.measurement_vars_inj, abstract_caget)
''' Now for the non-injection measurements '''
if get_command('SR-DI-DCCT-01:SIGNAL') > beam_current_bounds[1]:
beam_current_max_warning = True
# Stop injection
print "Stop injection"
caput('LI-TI-MTGEN-01:STOP', 1)
cothread.Sleep(0.1)
caput('LI-TI-MTGEN-01:STOP', 0)
cothread.Sleep(1)
mrs_noinj = measure_results(self.measurement_vars_noinj,
abstract_caget)
''' Now combine the results into a single list '''
results = mrs_noinj + mrs_inj
mrs = results
return mrs, beam_current_max_warning
def test_oneshot(self):
l = []
def tick():
l.append(1)
t = cothread.Timer(0.1, tick, reuse=True)
self.assertEqual(l, [])
cothread.Sleep(0.2)
self.assertEqual(l, [1])
cothread.Sleep(0.2)
self.assertEqual(l, [1])
t.reset(0.05)
self.assertEqual(l, [1])
cothread.Sleep(0.1)
self.assertEqual(l, [1, 1])
cothread.Sleep(0.1)
self.assertEqual(l, [1, 1])
def timer():
last = time.time()
last_callbacks = 0
while True:
cothread.Sleep(1)
now = time.time()
print("%d callbacks" % callbacks, callbacks - last_callbacks)
last = now
last_callbacks = callbacks
def test_rate_conversion(self):
channel = MagicMock()
listener = MagicMock()
sub = Subscription(channel, listener, 0.01)
channel.value = 32
sub.cb_value(channel.value)
channel.value = 33
sub.cb_value(channel.value)
listener.cb_value.assert_called_once_with(sub, 32)
listener.cb_value.reset_mock()
channel.value = 34
cothread.Sleep(0.01)
sub.cb_value(channel.value)
listener.cb_value.assert_called_once_with(sub, 34)
listener.cb_value.reset_mock()
channel.value = 35
cothread.Sleep(0.01)
sub.cb_value(channel.value)
listener.cb_value.assert_called_once_with(sub, 35)
def main():
for i in range(2):
print "Acquire " + str(i)
#Set up ROI1 on XY and enable ROI filter
caput("BL99:Det:N1:Det1:PixelROIFilterEnable",
1,
wait=True,
timeout=20)
caput("BL99:Det:N1:Start", 1, wait=True, timeout=2000)
status = caget("BL99:Det:N1:DetectorState_RBV")
if (status != STAT_ACQUIRE):
print "ERROR on Start: i= " + str(i) + \
" status= " + str(status) + " and it should be " + str(STAT_ACQUIRE)
sys.exit(1)
for x in range(32):
for y in range(32):
print "x: " + str(x)
print "y: " + str(y)
caput("BL99:Det:N1:Det1:XY:ROI:1:MinX",
x,
wait=True,
timeout=20)
caput("BL99:Det:N1:Det1:XY:ROI:1:MinY",
y,
wait=True,
timeout=20)
for xsize in range(32):
for ysize in range(32):
print "xsize: " + str(xsize)
print "ysize: " + str(ysize)
caput("BL99:Det:N1:Det1:XY:ROI:1:SizeX",
xsize,
wait=True,
timeout=20)
caput("BL99:Det:N1:Det1:XY:ROI:1:SizeY",
ysize,
wait=True,
timeout=20)
cothread.Sleep(0.1)
caput("BL16B:Det:ADnED:Stop", 1, wait=True, timeout=2000)
status = caget("BL16B:Det:ADnED:DetectorState_RBV")
if (status != STAT_IDLE):
print "ERROR on Stop: i= " + str(i) + \
" status= " + str(status) + " and it should be " + str(STAT_IDLE)
sys.exit(1)
def pollDMOVs(self):
for motor in self.getMotors():
dmov = 0
pv_dmov = self.getPVBase() + motor + ".DMOV"
while (dmov == 0):
cothread.Sleep(0.1)
dmov = self.getPv(pv_dmov)
if dmov:
self.diagnostic("Motor " + str(motor) + " has finished.")
self.diagnostic("All motors finished.")
def main():
for i in range(10000):
print "Acquire " + str(i)
error = False
caput("BL1A:Det:ADnED:Start", 1, wait=True, timeout=10)
status = caget("BL1A:Det:ADnED:State")
if (status != STAT_OK):
print "ERROR on ADnED start. High level status: " + str(status) + ". It should be " + str(STAT_OK)
adned_status = caget("BL1A:Det:N1:DetectorState_RBV")
adned_status_msg = caget("BL1A:Det:N1:StatusMessage_RBV")
print "ADnED status: " + str(adned_status) + ". Message: " + str(adned_status_msg)
error = True
if error:
cothread.Sleep(1)
status = caget("BL1A:Det:N1:DetectorState_RBV")
print "ADnED delayed status read: " + str(status)
status = caget("BL1A:Det:N1:DetectorState_RBV")
sys.exit(1)
cothread.Sleep(1)
caput("BL1A:Det:ADnED:Stop", 1, wait=True, timeout=10)
#cothread.Sleep(1) #At the moment callback not supported on a stop.
status = caget("BL1A:Det:ADnED:State")
if (status != STAT_OK):
print "ERROR on Stop. High level status: " + str(status) + ". It should be " + str(STAT_OK)
adned_status = caget("BL1A:Det:N1:DetectorState_RBV")
adned_status_msg = caget("BL1A:Det:N1:StatusMessage_RBV")
print "ADnED Status: " + str(adned_status) + ". Message: " + str(adned_status_msg)
error = True
if error:
cothread.Sleep(1)
status = caget("BL1A:Det:N1:DetectorState_RBV")
print "ADnED delayed status read: " + str(status)
sys.exit(1)
def runTest(self):
for motor in self.getMotors():
self.diagnostic(
"motorCaseMoveCheckStatus for motor " + str(motor) + "...",
self.getDiag())
pv_val = self.getPVBase() + motor + ".VAL"
pv_dmov = self.getPVBase() + motor + ".DMOV"
pv_msta = self.getPVBase() + motor + ".MSTA"
pv_dir = self.getPVBase() + motor + ".DIR"
pv_stop = self.getPVBase() + motor + ".STOP"
#First move motor to zero
self.diagnostic("Move to zero.", self.getDiag())
self.putPv(pv_val, 0.0, wait=True, timeout=self.getTimeout())
#Check MSTA Done is set
self.verify(0x2, (int(self.getPv(pv_msta)) & 0x2))
#Not do a move, with no callback
self.diagnostic("Move to 100.", self.getDiag())
self.putPv(pv_val, 100.0, wait=False)
#Use cothread sleep instead of time.sleep(), which blocks the cothread library (stopping the previous caput working).
cothread.Sleep(2.0)
#Read DIR field
direction = self.getPv(pv_dir)
if (direction == 0):
#Check MSTA Done is not set, and moving flag is on and direction positive is on.
self.verify(0x401, (int(self.getPv(pv_msta)) & 0x401))
else:
#Check MSTA Done is not set, and moving flag is on.
self.verify(0x400, (int(self.getPv(pv_msta)) & 0x400))
#Now stop it, check status, and move back to zero
self.diagnostic("Stopping.", self.getDiag())
self.putPv(pv_stop, 1, wait=True, timeout=self.getTimeout())
self.diagnostic("Move completed. Do final MSTA checks.",
self.getDiag())
#Check MSTA Done is set
self.verify(0x2, (int(self.getPv(pv_msta)) & 0x2))
#Check MSTA moving is not set
self.verify(0x0, (int(self.getPv(pv_msta)) & 0x400))
#Move back to zero
self.diagnostic("Move back to zero.", self.getDiag())
self.putPv(pv_val, 0.0, wait=True, timeout=self.getTimeout())
def rampingPut(self):
try:
step = int(self.stepLineEdit.text())
delay = float(self.delayLineEdit.text())
except:
print("No ramping: wrong settings of Step or Delay time.")
QMessageBox.warning(
self, 'Warning',
'No ramping: wrong settings of Step or Delay time. Please try again'
)
return
#print("Number of steps: %d; Waiting time between steps: %d"%(step, delay))
if step < 1:
print("No ramping: number of steps can't be zero")
QMessageBox.warning(
self, 'Warning',
'No ramping: the number of Steps should be >=1. Please try again'
)
return
try:
curValues = caget(self.rampPVList, timeout=2, throw=False)
except:
print(
"Oops: can't get PV values to ramp the machine, but will try one-step simple restore"
)
traceback.print_exc()
#QMessageBox.warning(self, 'Warning', "No multiple-step gradual put: some PVs seem disconnected")
return True #try one-step simple put
#print(self.rampPVList)
#print(curValues)
#print(self.rampRestoreData)
try:
stepSize = [(i - j) / step
for i, j in zip(self.rampRestoreData, curValues)]
#print(stepSize)
for l in range(1, step):
stepValues = [l * m + n for m, n in zip(stepSize, curValues)]
#print(stepValues)
caput(self.rampPVList, stepValues)
cothread.Sleep(delay)
except:
print(
"Oops: something wrong with ramping machine, but will try one-step simple restore"
)
traceback.print_exc()
#QMessageBox.warning(self, 'Warning', "Oops: something wrong with multiple-step gradual put")
return True
def set_params(param_vars, settings, set_command):
"""
change the parameters using set_command. This will usually be abstract_caput
"""
# Calculate the maximum delay time
max_delay = 0
for i in param_vars:
if i.delay > max_delay:
max_delay = i.delay
# Set the parameters
for i in range(len(param_vars)):
set_command(param_vars[i].pv, settings[i])
# Sleep for the appropriate amount of time
cothread.Sleep(max_delay)
def put(self, pv, op):
if self.busy:
op.done(error="Move in progress")
return
self.busy = True
try:
initial = self.pos
final = op.value()
delta = abs(final-initial)
op.info("Moving %s -> %s"%(initial, final))
while delta>=1.0:
op.info("Moving %s"%delta)
delta -= 1.0
cothread.Sleep(1.0) # move at 1 step per second
self.pos = final
op.done()
finally:
self.busy = False
def on_configure(
self,
context: scanning.hooks.AContext,
completed_steps: scanning.hooks.ACompletedSteps,
steps_to_do: scanning.hooks.AStepsToDo,
part_info: scanning.hooks.APartInfo,
generator: scanning.hooks.AGenerator,
fileDir: scanning.hooks.AFileDir,
**kwargs: Any,
) -> None:
super(TucsenDriverPart, self).on_configure(
context,
completed_steps,
steps_to_do,
part_info,
generator,
fileDir,
**kwargs,
)
cothread.Sleep(1.5)
def main():
for i in range(1000):
print "Acquire " + str(i)
caput("BL99:Det:N1:Start", 1, wait=True, timeout=5)
status = caget("BL99:Det:N1:DetectorState_RBV")
if (status != STAT_ACQUIRE):
print "ERROR on Start: i= " + str(i) + \
" status= " + str(status) + " and it should be " + str(STAT_ACQUIRE)
sys.exit(1)
cothread.Sleep(1)
caput("BL99:Det:N1:Stop", 1, wait=True, timeout=5)
status = caget("BL99:Det:N1:DetectorState_RBV")
if (status != STAT_IDLE):
print "ERROR on Stop: i= " + str(i) + \
" status= " + str(status) + " and it should be " + str(STAT_IDLE)
sys.exit(1)
def test_spawn_locked(self):
def set_v1():
with self.o:
self.v = 1
# check our setter works in isolation
assert self.v is None
cothread.Spawn(set_v1).Wait()
assert self.v == 1
# now do a long running task works
with self.o:
self.v = 2
assert self.v == 2
# start our thing that will be blocked, then sleep to make sure
# it can't do its thing
s = cothread.Spawn(set_v1)
cothread.Sleep(0.2)
assert self.v == 2
# now wait for the other to complete, and check it could
s.Wait()
assert self.v == 1
def _co_execute(self):
"""Execute the virtual accelerator. This includes the following:
1. Creating a temporary working directory for execution of FLAME.
2. Set up the working directory by symlinking from the data directory.
3. Writing the EPICS DB to the working directory (va.db).
4. Starting the softIoc and channel initializing monitors.
5. Add noise to the settings for all input (CSET) channels.
6. Create or update the FLAME machine configuration.
7. Propagate the FLAME simulation and read the results.
8. Update the READ channels of all devives.
9. Update the REST channels of input devies.
10. Repeat from step #5.
"""
_LOGGER.debug("VA: Execute virtual accelerator")
_LOGGER.info("VA: Running at " + self._ts_now)
chanprefix = self._chanprefix
if self._pv_suffix != '':
suffix_str = "_" + self._pv_suffix
else:
suffix_str = ""
# Add channel for VA rep-rate
chanrate = f"{chanprefix}:SVR:RATE{suffix_str}"
self._epicsdb.append(("ao", chanrate, OrderedDict([
("DESC", "Rep-rate of Simulation Engine"),
("VAL", self._rate),
("PREC", 1),
])))
_LOGGER.info("VA: Reprate PV is " + chanrate)
# Add channel for sample counting
chansample_cnt = f"{chanprefix}:SVR:CNT{suffix_str}"
self._epicsdb.append(("ao", chansample_cnt, OrderedDict([
("DESC", "Sample counter for scan client"),
("VAL", 0)
])))
# Add channel for VA configuration and control
channoise = f"{chanprefix}:SVR:NOISE{suffix_str}"
self._epicsdb.append(("ao", channoise, OrderedDict([
("DESC", "Noise level of Virtual Accelerator"),
("VAL", self._noise),
("PREC", 5)
])))
_LOGGER.info("VA: Noise PV is " + channoise)
chanstat = f"{chanprefix}:SVR:STATUS{suffix_str}"
self._epicsdb.append(("bi", chanstat, OrderedDict([
("DESC", "Status of Virtual Accelerator"),
("VAL", 1),
("ZNAM", "ERR"),
("ONAM", "OK"),
("PINI", "1")
])))
_LOGGER.info("VA: Status PV is " + chanstat)
# MPS status
chan_mps_stat = f"{chanprefix}:SVR:MpsStatus"
self._epicsdb.append(("mbbi", chan_mps_stat, OrderedDict([
("DESC", "MPS Status of Virtual Accelerator"),
("VAL", 3),
("ZRST", "Fault"),
("ONST", "Disable"),
("TWST", "Monitor"),
("THST", "Enable"),
("PINI", "1")
])))
_LOGGER.info("VA: MPS PV is " + chan_mps_stat)
#
chancharge = f"{chanprefix}:SVR:CHARGE{suffix_str}"
self._epicsdb.append(("ai", chancharge, OrderedDict([
("DESC", "Q/M of Virtual Accelerator"),
("VAL", 0.0),
("PREC", 5)
])))
# initial beam condition
chanbsrc = f"{chanprefix}:SVR:BEAM{suffix_str}"
self._epicsdb.append(("waveform", chanbsrc, OrderedDict([
("DESC", "Init beam of Virtual Accelerator"),
("NELM", 4096),
("FTVL", "UCHAR")
])))
_LOGGER.info("VA: Init beam condition PV is " + chanbsrc)
#
if self.work_dir is not None:
os.makedirs(self.work_dir)
self._rm_work_dir = False
latticepath = os.path.join(self.work_dir, "test.lat")
else:
self.work_dir = tempfile.mkdtemp(_TEMP_DIRECTORY_SUFFIX)
self._rm_work_dir = True
latticepath = None
_LOGGER.info("VA: Working directory: %s", self._work_dir)
# input file paths
epicsdbpath = os.path.join(self.work_dir, "va.db")
#output file paths
epicslogpath = os.path.join(self.work_dir, "softioc.log")
if os.path.isabs(self.data_dir):
abs_data_dir = self.data_dir
self._latfactory.dataDir = self.data_dir
else:
abs_data_dir = os.path.abspath(self.data_dir)
self._latfactory.dataDir = os.path.abspath(self.data_dir)
with open(epicsdbpath, "w") as outfile:
self._write_epicsdb(outfile)
_LOGGER.info("VA: Write EPICS database to %s", epicsdbpath)
#_LOGGER.debug("VA: Write EPICS database to %s", epicsdbpath)
self._ioc_logfile = open(epicslogpath, "w")
self._ioc_process = Popen(["softIoc", "-d", "va.db"], cwd=self.work_dir,
stdout=self._ioc_logfile, stderr=subprocess.STDOUT)
_LOGGER.debug("VA: Start EPICS soft IOC with log %s", epicslogpath)
_LOGGER.debug("VA: Connecting to channels: {}".format(len(self._csetmap.keys())))
self._subscriptions = []
self._subscriptions.append(catools.camonitor(chanrate, self._handle_rate_monitor))
self._subscriptions.append(catools.camonitor(channoise, self._handle_noise_monitor))
self._subscriptions.append(catools.camonitor(chanbsrc, self._handle_bsrc_monitor))
self._subscriptions.extend(catools.camonitor(self._csetmap.keys(), self._handle_cset_monitor))
_LOGGER.debug("VA: Connecting to channels: Done")
machine = None
while self._continue:
# update the RSET channels with new settings
batch = catools.CABatch()
for cset in self._csetmap.items():
name, field = self._fieldmap[cset[0]]
batch[cset[1][0]] = self._settings[name][field]
batch.caput()
settings = self._copy_settings_with_noise()
self._latfactory.settings = settings
lattice = self._latfactory.build()
start = time.time()
if machine is None:
_LOGGER.debug("VA: Create FLAME machine from configuration")
machine = Machine(lattice.conf())
else:
_LOGGER.debug("VA: Reconfigure FLAME machine from configuration")
for idx, elem in enumerate(lattice.elements):
machine.reconfigure(idx, elem[2])
if self._bsrc is not None:
_LOGGER.info("VA: Reconfigure FLAME machine with init beam config")
machine.reconfigure(self._bsrc['index'], self._bsrc['properties'])
if latticepath is not None:
_LOGGER.debug(f"VA: Write FLAME lattice file to {outfile}")
generate_latfile(machine, latfile=latticepath)
_LOGGER.debug("VA: Allocate FLAME state from configuration")
S = machine.allocState({})
output_map = []
for elem in lattice.elements:
if 'name' in elem[3]:
output_map.append(elem[3]['name'])
else:
output_map.append(None)
batch = catools.CABatch()
for i in range(0, len(machine)):
machine.propagate(S, i, 1)
if output_map[i] in self._elemmap:
elem = self._elemmap[output_map[i]]
if isinstance(elem, BPMElement):
x_centroid = S.moment0_env[0]/1.0e3 # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.x_phy], x_centroid)
batch[self._readfieldmap[elem.name][elem.fields.x_phy]] = x_centroid
y_centroid = S.moment0_env[2]/1.0e3 # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.y_phy], y_centroid)
batch[self._readfieldmap[elem.name][elem.fields.y_phy]] = y_centroid
# convert rad to deg and adjust for 161MHz sampling frequency
phase = _normalize_phase(2.0 * S.ref_phis * (180.0 / math.pi))
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.phase_phy], phase)
batch[self._readfieldmap[elem.name][elem.fields.phase_phy]] = phase
energy = S.ref_IonEk/1.0e6 # convert eV to MeV
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.energy_phy], energy)
batch[self._readfieldmap[elem.name][elem.fields.energy_phy]] = energy
elif isinstance(elem, PMElement):
x_centroid = S.moment0_env[0]/1.0e3 # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.x], x_centroid)
batch[self._readfieldmap[elem.name][elem.fields.x]] = x_centroid
y_centroid = S.moment0_env[2]/1.0e3 # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.y], y_centroid)
batch[self._readfieldmap[elem.name][elem.fields.y]] = y_centroid
x_rms = S.moment0_rms[0]/1.0e3 # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.xrms], x_rms)
batch[self._readfieldmap[elem.name][elem.fields.xrms]] = x_rms
y_rms = S.moment0_rms[2]/1.0e3
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.yrms], y_rms)
batch[self._readfieldmap[elem.name][elem.fields.yrms]] = y_rms
sign = elem.sign
xy_centroid = (sign*x_centroid + y_centroid)/math.sqrt(2.0) # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.xy], xy_centroid)
batch[self._readfieldmap[elem.name][elem.fields.xy]] = xy_centroid
xy_rms = 1.0e-3*math.sqrt(
(S.moment1_env[0, 0] + S.moment1_env[2, 2])*0.5
+ sign*S.moment1_env[0, 2]
)
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.xyrms], xy_rms)
batch[self._readfieldmap[elem.name][elem.fields.xyrms]] = xy_rms
cxy = sign * S.moment1_env[0, 2] * 1e-6 / x_rms / y_rms
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.cxy], cxy)
batch[self._readfieldmap[elem.name][elem.fields.cxy]] = cxy
elif isinstance(elem, (FCElement, VDElement, TargetElement, DumpElement, WedgeElement)):
x_centroid = S.moment0_env[0]/1.0e3 # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.x], x_centroid)
batch[self._readfieldmap[elem.name][elem.fields.x]] = x_centroid
y_centroid = S.moment0_env[2]/1.0e3 # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.y], y_centroid)
batch[self._readfieldmap[elem.name][elem.fields.y]] = y_centroid
x_rms = S.moment0_rms[0]/1.0e3 # convert mm to m
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.xrms], x_rms)
batch[self._readfieldmap[elem.name][elem.fields.xrms]] = x_rms
y_rms = S.moment0_rms[2]/1.0e3
_LOGGER.debug("VA: Update read: %s to %s",
self._readfieldmap[elem.name][elem.fields.yrms], y_rms)
batch[self._readfieldmap[elem.name][elem.fields.yrms]] = y_rms
batch.caput()
_LOGGER.info("VA: FLAME execution time: %f s", time.time()-start)
# Allow the BPM, PM, etc. readbacks to update
# before the device setting readbacks PVs.
cothread.Yield()
batch = catools.CABatch()
for name, value in self._csetmap.items():
name, field = self._fieldmap[name]
_LOGGER.debug("VA: Update read: %s to %s", value[1], settings[name][field])
batch[value[1]] = settings[name][field]
batch.caput()
# Sleep for a fraction (10%) of the total execution time
# when one simulation costs more than 0.50 seconds.
# Otherwise, sleep for the rest of 1 second.
# If a scan is being done on this virtual accelerator,
# then the scan server has a period of time to update
# setpoints before the next run of IMPACT.
delt = time.time() - start
if delt > 0.50:
cothread.Sleep(delt * 0.1)
else:
cothread.Sleep(1.0 / self._rate - delt)
def worker(n, event):
event.Wait()
for i in range(25):
print(f"{n}", end="")
cothread.Sleep(random.random() * 0.5) # suspend cothread
print()
import cothread
import random
def worker(n, event):
event.Wait()
for i in range(25):
print(f"{n}", end="")
cothread.Sleep(random.random() * 0.5) # suspend cothread
print()
threads = []
event = cothread.Event(auto_reset=False)
# auto_reset=True: let only one cothread see the signal
# auto_reset=False: let all cothreads see the signal
for n in range(1, 5):
t = cothread.Spawn(worker, n, event)
threads.append(t)
delay = 10
print(f"main cothread waiting for {delay} seconds")
cothread.Sleep(delay)
event.Signal()
for t in threads:
t.Wait()
def test_starts_ioc(self):
cothread.Sleep(5)
assert catools.caget(self.prefix + ":PYMALCOLM:VER") in ["work", __version__]
def get_mr(self):
#mrs = measure_results(self.measurement_vars, model.caget)
average_inj = [0] * len(self.measurement_vars_inj)
counts_inj = [0] * len(self.measurement_vars_inj)
dev_inj = [0] * len(self.measurement_vars_inj)
average_noinj = [0] * len(self.measurement_vars_noinj)
counts_noinj = [0] * len(self.measurement_vars_noinj)
dev_noinj = [0] * len(self.measurement_vars_noinj)
''' Final ones '''
#average = [0] * len(measurement_vars)
#counts = [0] * len(measurement_vars)
#dev = [0] * len(measurement_vars)
get_command = model.caget
run = True
start_time = time.time()
''' First measure the injection results '''
# Begin injecting
print "Start injection"
#caput('LI-TI-MTGEN-01:START', 1)
cothread.Sleep(0.1)
#caput('LI-TI-MTGEN-01:START', 0)
cothread.Sleep(1)
run = True
start_time = time.time()
while run:
# Check whether to make any measurements
for i in range(len(self.measurement_vars_inj)):
# If the time since start is > the measurement delay * number of times its been counted, then
if (time.time() - start_time) > (
self.measurement_vars_inj[i].delay * counts_inj[i]):
print "Measuring {0}".format(
self.measurement_vars_inj[i].pv)
value = get_command(self.measurement_vars_inj[i].pv)
average_inj[i] += value
counts_inj[i] += 1
dev_inj[i] += value**2
# Check if finished
run = False
for i in range(len(self.measurement_vars_inj)):
# If the number counted is less than that required, then carry on, else you can stop
if counts_inj[i] < self.measurement_vars_inj[i].min_counts:
run = True
average_inj = [
average_inj[i] / counts_inj[i] for i in range(len(average_inj))
]
dev_inj = [(dev_inj[i] / counts_inj[i]) - average_inj[i]**2
for i in range(len(average_inj))]
err_inj = [(dev_inj[i]) / (math.sqrt(counts_inj[i]))
for i in range(len(average_inj))]
# Return results back to the optimiser
#return average We would previously just return the number. Now we will return a measurement object
results_inj = []
for i in range(len(average_inj)):
results_inj.append(
measurement(mean=average_inj[i],
counts=counts_inj[i],
dev=dev_inj[i],
err=err_inj[i]))
''' Now for the non-injection measurements '''
# Stop injection
print "Stop injection"
#caput('LI-TI-MTGEN-01:STOP', 1)
cothread.Sleep(0.1)
#caput('LI-TI-MTGEN-01:STOP', 0)
cothread.Sleep(1)
run = True
start_time = time.time()
while run:
# Check whether to make any measurements
for i in range(len(self.measurement_vars_noinj)):
# If the time since start is > the measurement delay * number of times its been counted, then
if (time.time() -
start_time) > (self.measurement_vars_noinj[i].delay *
counts_noinj[i]):
print "Measuring {0}".format(
self.measurement_vars_noinj[i].pv)
value = get_command(self.measurement_vars_noinj[i].pv)
average_noinj[i] += value
counts_noinj[i] += 1
dev_noinj[i] += value**2
# Check if finished
run = False
for i in range(len(self.measurement_vars_noinj)):
# If the number counted is less than that required, then carry on, else you can stop
if counts_noinj[i] < self.measurement_vars_noinj[i].min_counts:
run = True
average_noinj = [
average_noinj[i] / counts_noinj[i]
for i in range(len(average_noinj))
]
dev_noinj = [(dev_noinj[i] / counts_noinj[i]) - average_noinj[i]**2
for i in range(len(average_noinj))]
err_noinj = [(dev_noinj[i]) / (math.sqrt(counts_noinj[i]))
for i in range(len(average_noinj))]
# Return results back to the optimiser
#return average We would previously just return the number. Now we will return a measurement object
results_noinj = []
for i in range(len(average_noinj)):
results_noinj.append(
measurement(mean=average_noinj[i],
counts=counts_noinj[i],
dev=dev_noinj[i],
err=err_noinj[i]))
''' Now combine the results into a single list '''
results = results_noinj + results_inj
mrs = results
return mrs
def _sleep(self, delay):
cothread.Sleep(delay)
def test_ioc_ticks(self):
cothread.Sleep(5)
uptime = catools.caget(self.prefix + ":UPTIME:RAW")
assert uptime >= 0
time.sleep(5)
assert catools.caget(self.prefix + ":UPTIME:RAW") >= uptime + 5
def worker(n):
for i in range(25):
print(f"{n}", end="")
cothread.Sleep(random.random() * 0.5) # suspend cothread
print()
