def __init__(self, host, platform, prefix, ioc_prefix, ioc_name):
super(DaqDriver, self).__init__()
self.run = True
self.connected = False
self.prefix = prefix
self.pvdb = pvdb
self.setParam('HOST', host)
self.setParam('PLATFORM', platform)
self.ioc = IocAdmin(ioc_name, ioc_prefix, self)
self.host = self.getParam('HOST')
self.platform = self.getParam('PLATFORM')
self.confpv = self.get_tagged_pvs('config')
self.readonly = self.get_tagged_pvs('readonly')
self.cmds = self.get_tagged_pvs('daqcmd')
self.daq = self.daq = pydaq.Control(host=self.host,
platform=self.platform)
self.refresh = 1.0
for pv in self.pvdb.keys():
# remove the invalid state
self.setParamStatus(pv, Alarm.NO_ALARM, Severity.NO_ALARM)
self.eid = Queue.Queue()
self.sig = threading.Event()
self.lock = threading.Lock()
self.lock.acquire()
self.tid = threading.Thread(target=self.runDAQ)
self.tid.setDaemon(True)
self.tid.start()
self.nid = threading.Thread(target=self.runNumEvent)
self.nid.setDaemon(True)
self.nid.start()
def get_src_info(src):
"""
Encodes a detinfo src string into its integer equivalent
"""
daq = pydaq.Control('test')
detname, detid, devname, devid = src.split("/")
det = daq.detectors().index(detname) & 0xff
detid = int(detid) & 0xff
dev = daq.devices().index(devname) & 0xff
devid = int(devid) & 0xff
return (det << 24) | (detid << 16) | (dev << 8) | devid
def get_db_from_daq(daqinfo):
try:
host, platform = daqinfo.split(":")
except ValueError:
host = daqinfo
platform = 0
daq = pydaq.Control(host, platform)
daq.connect()
dbalias = daq.dbalias()
dbpath = daq.dbpath()
daq.disconnect()
return dbpath, dbalias
def __init__(self, daq_host, daq_platform, laser_delay_pv_name,
tt_stage_position_pv_name, t0_pv_name, laser_lock_pv_name):
"""
Create a Timescaner instance, providing control over the timetool
and laser delay stages.
Parameters
----------
daq_host : str
daq_platform : int
laser_delay_pv_name : str
tt_stage_position_pv_name : str
t0_pv_name : str
laser_lock_pv_name : str
See Also
--------
Timescaner.from_rc() : function
Create a timescaner instance from a file.
"""
self._daq_host = daq_host
self._daq_platform = daq_platform
self.daq = pydaq.Control(daq_host, daq_platform)
self._laser_delay = epics.PV(laser_delay_pv_name)
self._tt_stage_position = epics.PV(tt_stage_position_pv_name)
self._t0 = epics.PV(t0_pv_name)
self._laser_lock = epics.PV(laser_lock_pv_name)
self.tt_travel_offset = 0.0
self.tt_fit_coeff = np.array([0.0, 1.0, 0.0])
self.calibrated = False
time.sleep(0.1) # time for PVs to connect
for pv in [
self._laser_delay, self._tt_stage_position, self._t0,
self._laser_lock
]:
if not pv.connected:
raise RuntimeError('Cannot connect to PV: %s' % pv.pvname)
return
def init(self):
self.pvLaserShutter = None
if self.iShutter > 0 and self.iShutter <= len(self.lPvShutter):
self.pvLaserShutter = self.lPvShutter[self.iShutter-1]
fBeamFullRate = float(caget(pvBeamRate));
if not self.bSimMode:
print "\n## Beam rate = %.1f HZ" % (fBeamFullRate)
if not (self.dictBeamToBurstRate.has_key(fBeamFullRate)):
print "!!! Beam rate is not stable, please wait for beam to stablize and run the script again"
return 1
self.mccBurst.mccBurstCheckInit()
if self.fBurstRate == -1:
if self.bSimMode:
self.fBurstRate = 120.0
else:
self.fBurstRate = fBeamFullRate
if not self.bSimMode:
self.mccBurst.mccBurstSetNumShot(self.iNumShot, self.dictBeamToBurstRate[self.fBurstRate])
print "## Burst rate = %.1f HZ" % (self.fBurstRate)
print "## Multiple shot: %d" % (self.iNumShot)
self.daq = pydaq.Control(self.daq_host, self.daq_platform)
print ' *** DaqMultipleShot.init(): self.controls =', self.controls
#
# Send the structure the first time to put the control variables
# in the file header
print "daq connect...",
sys.stdout.flush()
try:
self.daq.connect() # get dbpath and key from DAQ
except Exception, e:
print e
print "Please select devices and click Select in the DAQ Control window"
def _get_device_config_handlers():
special_handlers = {
'Jungfrau': JungfrauConfig,
'Epix10ka': EpixConfig,
'Epix10kaQuad': EpixConfig,
'Epix10ka2M': EpixConfig,
}
excluded_handlers = {
'NoDevice',
'Evr',
'Acqiris',
'Ipimb',
'Encoder',
'AcqTDC',
'Xamps',
'Fexamp',
'Gsc16ai',
'OceanOptics',
'USDUSB',
'Imp',
'Epix',
'EpixSampler',
'Wave8',
'LeCroy',
'JungfrauSegment',
'JungfrauSegmentM2',
'JungfrauSegmentM3',
'JungfrauSegmentM4',
'QuadAdc',
}
daq = pydaq.Control(0)
return {
dev: special_handlers.get(dev, SimpleConfig)
for dev in daq.devices() if dev not in excluded_handlers
}
def init(self):
self.pvLaserShutter = None
if self.iShutter > 0 and self.iShutter <= len(self.lPvShutter):
self.pvLaserShutter = self.lPvShutter[self.iShutter-1]
fBeamFullRate = float(caget(pvBeamRate));
if not self.bSimMode:
print "\n## Beam rate = %.1f HZ" % (fBeamFullRate)
if not (self.dictBeamToBurstRate.has_key(fBeamFullRate)):
print "!!! Beam rate is not stable, please wait for beam to stablize and run the script again"
return 1
self.mccBurst.mccBurstCheckInit()
caput(pvPlayMode , 0) # PlayMode = Once
caput(pvMccSeqSyncMarker , 6) # Set sequencer sync marker to 120Hz
caput(pvMccSeqBeamRequest, 0) # Set seuqencer rate to be 120Hz (TS4|TS1)
if self.bSimMode:
caput(pvMccSynEvtBurst , 0) # Diable SEB support
else:
caput(pvMccSynEvtBurst , 1) # Enable SEB support
if self.fBurstRate == -1:
if self.bSimMode:
self.fBurstRate = 120.0
else:
self.fBurstRate = fBeamFullRate
if not self.bSimMode:
self.mccBurst.mccBurstSetNumShot(self.iNumShot, self.dictBeamToBurstRate[self.fBurstRate])
print "## Burst rate = %.1f HZ" % (self.fBurstRate)
print "## Multiple shot: %d" % (self.iNumShot)
self.codeCommand = self.setPrincetonExposureSequence()
# Exposure Time =
# delay from "real" princeton open and SEB burst start event (0 second)
# delay from SEB burst start event and MCC firing beam ( max( 1/60, 1/self.fBurstRate) )
# (x) + laser shutter open delay (Pv set + shutter physical open) (0.5 second)
# + manual sleep (fExpDelay)
# + exposure Time ((self.iNumShot / self.fBurstRate) second)
# = 0.0 + (self.iNumShot / self.fBurstRate) + fExpDelay second
# Setup Time =
# delay between setting pvPlayCtrl and the "real" princeton open (0.2 second)
# = 0.2
self.fSetupTime = 0.1
self.fExposureTime = 0.0 + self.fExpDelay + self.iNumShot / float(self.fBurstRate) + max(1.0/120, 1.0/self.fBurstRate) + self.iSlowCamOpenDelay / 360.0
self.daq = pydaq.Control(self.daq_host, self.daq_platform)
print ' *** PrincetonDaqMultipleShot.init(): self.controls =', self.controls
#
# Send the structure the first time to put the control variables
# in the file header
print "daq connect...",
sys.stdout.flush()
try:
self.daq.connect() # get dbpath and key from DAQ
except Exception, e:
print e
print "Please select devices and click Select button in DAQ Control window"
print 'steps ', options.steps
print 'detector', hex(options.detector)
if (options.deviceOffset > 0):
print 'deviceOffset', options.deviceOffset, "so detector now", hex(
options.detector + options.deviceOffset)
options.detector = options.detector + options.deviceOffset
print 'typeID ', hex(options.typeID)
time.sleep(1)
print 'shutter ', options.shutter
time.sleep(0)
print 'exclude ', options.exclude
shutterActive = options.shutter != 'None'
# Connect to the daq system
daq = pydaq.Control(options.host, options.platform)
daq.connect()
print 'dark ', options.dark, 'events'
print 'bright ', options.events, 'events'
index = 0.0
if shutterActive:
ser = serial.Serial(options.shutter)
ser.write(chr(128)) ## close shutter
nodeFound = 'No'
partition = daq.partition()
if options.exclude != 'None':
for node in partition:
if node['id'] == options.exclude:
node['record'] = False
nodeFound = 'Yes'
print 'gap ', options.gap, 'events'
def scan_parameter(device, configtype, parameter, values, enumkey=None):
import sys
parser = OptionParser()
parser.add_option("-a",
"--address",
dest="host",
default='localhost',
help="connect to DAQ at HOST",
metavar="HOST")
parser.add_option("-p",
"--platform",
dest="platform",
type="int",
default=3,
help="connect to DAQ at PLATFORM",
metavar="PLATFORM")
parser.add_option("-D",
"--detector",
dest="detector",
type="string",
default='NoDetector',
help="detector to scan, default NoDetector",
metavar="DET")
parser.add_option("-I",
"--detectorID",
dest="detectorID",
type="int",
default=0,
help="detector ID to scan, default 0",
metavar="D_ID")
parser.add_option("-i",
"--deviceID",
dest="deviceID",
type="int",
default=0,
help="device ID to scan, default 0",
metavar="DEV_ID")
parser.add_option("-t",
"--typeIdVersion",
dest="typeIdVersion",
type="int",
default=1,
help="type ID Version in use, default 1",
metavar="typeIdVersion")
parser.add_option("-A",
"--dbalias",
dest="dbalias",
type="string",
help="data base key in use",
metavar="DBALIAS")
parser.add_option("-e",
"--events",
dest="events",
type="int",
default=1000,
help="record N events/cycle",
metavar="EVENTS")
parser.add_option("-u",
"--user",
dest="userFlag",
type="int",
default=1,
help="Iff zero then no user, default=1",
metavar="DARKEVENTS")
(options, args) = parser.parse_args()
options.device = device
options.typeId = configtype
print 'host', options.host
print 'platform', options.platform
print 'dbalias', options.dbalias
print 'detector', options.detector
print 'detectorID', options.detectorID
print 'device', options.device
print 'deviceID', options.deviceID
print 'events', options.events
print 'userFlag', options.userFlag
print 'device', device
print 'configtype', configtype
print 'parameter', parameter
print 'values', values
# Connect to the daq system
daq = pydaq.Control(options.host, options.platform)
daq.connect()
print 'Partition is', daq.partition()
detectors = daq.detectors()
devices = daq.devices()
types = daq.types()
# print 'types are :\n', types
found = [False, False, False]
index = 0
for member in detectors:
if member == options.detector:
detectorValue = (index << 24) | ((options.detectorID & 0xff) << 16)
found[0] = True
index = index + 1
index = 0
for member in devices:
if member == options.device:
detectorValue = detectorValue | (index << 8) | (options.deviceID
& 0xff)
found[1] = True
index = index + 1
index = 0
for member in types:
if member == options.typeId:
typeIdValue = index | (options.typeIdVersion << 16)
found[2] = True
index = index + 1
if found[0] and found[1] and found[2]:
print "detector hex value", hex(detectorValue)
print 'typeId', hex(typeIdValue)
else:
if not found[0]:
print "Detector", options.detector, "not found!"
if not found[1]:
print "Device", options.device, "not found!"
if not found[2]:
print "Type", options.typeId, "not found!"
print "Exiting"
exit()
#
# First, get the current configuration key in use and set the value to be used
#
cdb = pycdb.Db(daq.dbpath())
key = daq.dbkey()
alias = daq.dbalias()
print 'Retrieved key ' + hex(key) + ' alias ' + alias
#
# Generate a new key with different epix and EVR configuration for each cycle
#
if options.dbalias == None:
newkey = cdb.clone(alias)
else:
newkey = cdb.clone(options.dbalias)
print 'Generated key ', hex(newkey)
print 'key', hex(key)
print 'detectorValue', hex(detectorValue)
print 'typeIdValue', hex(typeIdValue)
xtc = cdb.get(key=key, src=detectorValue, typeid=typeIdValue)[0]
print 'xtc is', xtc
config = xtc.get(0)
if enumkey is not None:
enums = xtc.get_enums()[enumkey]
else:
enums = None
print 'Composing the sequence of configurations ...'
cycle = 0 # cycle number excluding skipped
for value in values:
if parameter in config:
if enums is not None:
config[parameter] = enums[value]
else:
config[parameter] = value
print config, cycle
xtc.set(config, cycle)
cycle += 1
cdb.substitute(newkey, xtc)
cdb.unlock()
print ' done'
# Send the structure the first time to put the control variables
# in the file header
#
daq.configure(key=newkey, events=options.events)
print "Configured."
#
# Wait for the user to declare 'ready'
# Setting up monitoring displays for example
#
if options.userFlag > 0:
ready = raw_input('--Hit Enter when Ready-->')
for value in values:
print 'parameter', parameter, 'value', value
daq.begin(events=options.events)
daq.end()
#
# Wait for the user to declare 'done'
# Saving monitoring displays for example
#
if options.userFlag > 0:
ready = raw_input('-- Finished, hit Enter to exit -->')
print 'Restoring key', hex(key)
daq.configure(key=key, events=1)
def scan_offset(device, configtype):
import sys
parser = OptionParser()
parser.add_option("-a",
"--address",
dest="host",
default='localhost',
help="connect to DAQ at HOST",
metavar="HOST")
parser.add_option("-p",
"--platform",
dest="platform",
type="int",
default=0,
help="connect to DAQ at PLATFORM",
metavar="PLATFORM")
parser.add_option("-D",
"--detector",
dest="detector",
type="string",
default='NoDetector',
help="detector to scan, default NoDetector",
metavar="DET")
parser.add_option("-I",
"--detectorID",
dest="detectorID",
type="int",
default=0,
help="detector ID to scan, default 0",
metavar="D_ID")
# parser.add_option("-d","--device",dest="device",type="string",default='Epix10ka',
# help="device to scan, default Epix10ka",metavar="DEV")
parser.add_option("-i",
"--deviceID",
dest="deviceID",
type="int",
default=0,
help="device ID to scan, default 0",
metavar="DEV_ID")
parser.add_option("-t",
"--typeIdVersion",
dest="typeIdVersion",
type="int",
default=1,
help="type ID Version in use, default 1",
metavar="typeIdVersion")
parser.add_option("-A",
"--dbalias",
dest="dbalias",
type="string",
help="data base key in use",
metavar="DBALIAS")
parser.add_option("-s",
"--space",
dest="space",
type="int",
default=7,
help="space is the spacing in the array",
metavar="SPACE")
parser.add_option("-e",
"--events",
dest="events",
type="int",
default=4608,
help="record N events/cycle",
metavar="EVENTS")
parser.add_option("-v",
"--value0",
dest="Value0",
type="int",
default=0,
help="Value0 for most of the pixel array, default=0 ",
metavar="VALUE0")
parser.add_option(
"-V",
"--value1",
dest="Value1",
type="int",
default=1,
help="Value1 for pixels under test in the pixel array, default=1",
metavar="VALUE1")
parser.add_option("-d",
"--darkEvents",
dest="darkEvents",
type="int",
default=1200,
help="Number of events in each Dark, default=1200 ",
metavar="DARKEVENTS")
parser.add_option("-u",
"--user",
dest="userFlag",
type="int",
default=1,
help="Iff zero then no user, default=1",
metavar="USERFLAG")
parser.add_option("-o",
"--cycleStart",
dest="cycleStart",
type="int",
default=0,
help="Starting at cycle number, default=0",
metavar="CYCLESTART")
parser.add_option("-O",
"--cycleStop",
dest="cycleStop",
type="int",
default=105,
help="Stopping at cycle number, default=105",
metavar="CYCLESTOP")
(options, args) = parser.parse_args()
options.device = device
options.typeId = configtype
# currently only the Epix10kaQuads and Epix10ka2M support the ghost correction
options.ghostCorrect = True if device in ['Epix10kaQuad', 'Epix10ka2M'
] else False
print 'host', options.host
print 'platform', options.platform
print 'dbalias', options.dbalias
print 'detector', options.detector
print 'detectorID', options.detectorID
print 'device', options.device
print 'deviceID', options.deviceID
if options.space > 7:
print 'Space is too large, truncated to 7'
options.space = 7
print 'space', options.space
print 'Values', options.Value0, ',', options.Value1
print 'darkEvents', options.darkEvents
print 'events', options.events
print 'userFlag', options.userFlag
print 'cycleStart', options.cycleStart
print 'cycleStop', options.cycleStop
print 'ghostCorrection', options.ghostCorrect
#Fixed High Gain , pixel matrix to 0xc trbit 1
#Fixed Medium Gain pixel matrix to 0xc trbit 0
#Fixed Low Gain pixel matrix to to 0x8 trbit don't care
#Auto High to Low pixel matrix to 0x0 trbit 1
#Auto Medium to low pixel matrix to 0x0 trbit 0
hasGhostCorrection = False
numberOfDarks = 5
darkValues = [0xc, 0xc, 0x8, 0, 0]
trBitValues = [1, 0, 0, 1, 0]
darkMessages = [
'Fixed High Gain', 'Fixed Medium Gain', 'Fixed Low Gain',
'Auto High to Low', 'Auto Medium to Low'
]
# Connect to the daq system
daq = pydaq.Control(options.host, options.platform)
daq.connect()
print 'Partition is', daq.partition()
detectors = daq.detectors()
devices = daq.devices()
types = daq.types()
# print 'types are :\n', types
found = [False, False, False]
index = 0
for member in detectors:
if member == options.detector:
detectorValue = (index << 24) | ((options.detectorID & 0xff) << 16)
found[0] = True
index = index + 1
index = 0
for member in devices:
if member == options.device:
detectorValue = detectorValue | (index << 8) | (options.deviceID
& 0xff)
found[1] = True
index = index + 1
index = 0
for member in types:
if member == options.typeId:
typeIdValue = index | (options.typeIdVersion << 16)
found[2] = True
index = index + 1
if found[0] and found[1] and found[2]:
print "detector hex value", hex(detectorValue)
print 'typeId', hex(typeIdValue)
else:
if not found[0]:
print "Detector", options.detector, "not found!"
if not found[1]:
print "Device", options.device, "not found!"
if not found[2]:
print "Type", options.typeId, "not found!"
print "Exiting"
exit()
#
# First, get the current configuration key in use and set the value to be used
#
cdb = pycdb.Db(daq.dbpath())
key = daq.dbkey()
alias = daq.dbalias()
print 'Retrieved key ' + hex(key) + ' alias ' + alias
#
# Generate a new key with different epix and EVR configuration for each cycle
#
if options.dbalias == None:
newkey = cdb.clone(alias)
else:
newkey = cdb.clone(options.dbalias)
print 'Generated key ', hex(newkey)
print 'key', hex(key)
print 'detectorValue', hex(detectorValue)
print 'typeIdValue', hex(typeIdValue)
xtc = cdb.get(key=key, src=detectorValue, typeid=typeIdValue)[0]
print 'xtc is', xtc
epix = xtc.get(0)
print 'Composing the sequence of configurations ...'
gcycle = 0 # cycle number if nothing skipped
cycle = 0 # cycle number excluding skipped
for dark in range(numberOfDarks):
if gcycle >= options.cycleStart and gcycle < options.cycleStop:
if 'elemCfg' in epix:
for e in epix['elemCfg']:
mask = e['asicMask']
for rows in range(352):
for cols in range(384):
e['asicPixelConfigArray'][rows][cols] = darkValues[
dark]
for asicNum in range(4):
if mask & (1 << asicNum):
e['asics'][asicNum]['trbit'] = trBitValues[dark]
else:
mask = epix['AsicMask']
for rows in range(352):
for cols in range(384):
epix['asicPixelConfigArray'][rows][cols] = darkValues[
dark]
for asicNum in range(4):
if mask & (1 << asicNum):
epix['asics'][asicNum]['trbit'] = trBitValues[dark]
xtc.set(epix, cycle)
cycle += 1
gcycle += 1
for trbit in [0, 1]:
for position in range(options.space**2):
if gcycle >= options.cycleStart and gcycle < options.cycleStop:
maskedpixels = pixel_mask(options.Value0, options.Value1,
options.space, position)
if 'elemCfg' in epix:
for e in epix['elemCfg']:
mask = e['asicMask']
for rows in range(352):
for cols in range(384):
e['asicPixelConfigArray'][rows][
cols] = maskedpixels[rows][cols]
for asicNum in range(4):
if mask & (1 << asicNum):
e['asics'][asicNum]['atest'] = 1
e['asics'][asicNum]['test'] = 1
e['asics'][asicNum]['trbit'] = trbit
e['asics'][asicNum]['Pulser'] = 0
if options.ghostCorrect:
e['asics'][asicNum]['PulserSync'] = 1
else:
mask = epix['AsicMask']
for rows in range(352):
for cols in range(384):
epix['asicPixelConfigArray'][rows][
cols] = maskedpixels[rows][cols]
for asicNum in range(4):
if mask & (1 << asicNum):
epix['asics'][asicNum]['atest'] = 1
epix['asics'][asicNum]['test'] = 1
epix['asics'][asicNum]['trbit'] = trbit
epix['asics'][asicNum]['Pulser'] = 0
if options.ghostCorrect:
epix['asics'][asicNum]['PulserSync'] = 1
if options.ghostCorrect:
if 'quads' in epix:
for q in epix['quads']:
q['asicAcqLToPPmatL'] = 1000
else:
epix['asicAcqLToPPmatL'] = 1000
xtc.set(epix, cycle)
cycle += 1
gcycle += 1
# print 'xtc.set(, epix', position + (trbit*(options.space**2)), ')'
cdb.substitute(newkey, xtc)
cdb.unlock()
print ' done'
# Send the structure the first time to put the control variables
# in the file header
#
cycle_label = [
('%s offset scan' % device, ''),
]
daq.configure(key=newkey, events=options.events, labels=cycle_label)
print "Configured."
#
# Wait for the user to declare 'ready'
# Setting up monitoring displays for example
#
if options.userFlag > 0:
ready = raw_input('--Hit Enter when Ready-->')
gcycle = 0
for dark in range(numberOfDarks):
if gcycle >= options.cycleStart and gcycle < options.cycleStop:
print 'dark', darkMessages[dark]
cycle_label = [
('%s offset scan' % device, 'dark %s' % darkMessages[dark]),
]
daq.begin(events=options.darkEvents, labels=cycle_label)
daq.end()
gcycle += 1
for trbit in [0, 1]:
for position in range(((options.space**2))):
if gcycle >= options.cycleStart and gcycle < options.cycleStop:
print 'position', position, 'trbit', trbit
cycle_label = [
('%s offset scan' % device,
'position %d trbit %d' % (position, trbit)),
]
daq.begin(events=options.events, labels=cycle_label)
daq.end()
gcycle += 1
#
# Wait for the user to declare 'done'
# Saving monitoring displays for example
#
if options.userFlag > 0:
ready = raw_input('-- Finished, hit Enter to exit -->')
print 'Restoring key', hex(key)
daq.configure(key=key, events=1)
def scan_exponential(device, configtype):
import sys
parser = OptionParser()
parser.add_option("-a",
"--address",
dest="host",
default='localhost',
help="connect to DAQ at HOST",
metavar="HOST")
parser.add_option("-p",
"--platform",
dest="platform",
type="int",
default=3,
help="connect to DAQ at PLATFORM",
metavar="PLATFORM")
parser.add_option("-D",
"--detector",
dest="detector",
type="string",
default='NoDetector',
help="detector to scan, default NoDetector",
metavar="DET")
parser.add_option("-I",
"--detectorID",
dest="detectorID",
type="int",
default=0,
help="detector ID to scan, default 0",
metavar="D_ID")
parser.add_option("-i",
"--deviceID",
dest="deviceID",
type="int",
default=0,
help="device ID to scan, default 0",
metavar="DEV_ID")
parser.add_option("-t",
"--typeIdVersion",
dest="typeIdVersion",
type="int",
default=1,
help="type ID Version in use, default 1",
metavar="typeIdVersion")
parser.add_option("-P",
"--parameter",
dest="parameter",
type="string",
help="epix parameter to scan",
metavar="PARAMETER")
parser.add_option("-A",
"--dbalias",
dest="dbalias",
type="string",
help="data base key in use",
metavar="DBALIAS")
parser.add_option("-s",
"--start",
dest="start",
type="float",
default=200,
help="parameter start",
metavar="START")
parser.add_option("-f",
"--finish",
dest="finish",
type="int",
nargs=1,
default=2000,
help="parameter finish",
metavar="FINISH")
parser.add_option(
"-m",
"--multiplier",
dest="multiplier",
type="float",
nargs=1,
default=-1.0,
help=
"parameter multiplier in case you want to enter it directly, ignoring FINISH",
metavar="MULTIPLIER")
parser.add_option("-n",
"--steps",
dest="steps",
type="int",
default=20,
help="run N parameter steps",
metavar="N")
parser.add_option("-e",
"--events",
dest="events",
type="int",
default=105,
help="record N events/cycle",
metavar="EVENTS")
parser.add_option(
"-L",
"--linear",
dest="linear",
type="string",
default="no",
help="Set to yes for linear scanning instead of exponential",
metavar="LINEAR")
parser.add_option(
"-l",
"--limit",
dest="limit",
type="int",
default=99,
help="limit number of configs to less than number of steps",
metavar="LIMIT")
parser.add_option("-S",
"--shutter",
dest="shutter",
default="None",
help="path to shutter serial port",
metavar="SHUTTER")
parser.add_option("-u",
"--use_l3t",
dest="use_l3t",
action="store_true",
default=False,
help="Use L3Trigger to filter events",
metavar="L3T")
(options, args) = parser.parse_args()
options.device = device
options.typeId = configtype
print 'host', options.host
print 'platform', options.platform
print 'dbalias', options.dbalias
print 'parameter', options.parameter
print 'start', options.start, options.start
print 'steps', options.steps
print 'finish', options.finish
# print 'multiplier', options.multiplier
print 'events', options.events
print 'detector', options.detector
print 'detectorID', options.detectorID
print 'device', options.device
print 'deviceID', options.deviceID
# print 'linear', options.linear
print 'shutter', options.shutter
print 'use_l3t', options.use_l3t
if options.steps < options.limit: options.limit = options.steps
else: print 'Warning, range will be covered in', options.limit, \
'but will still do', options.steps, 'steps with wrapping'
adder = 0.0
if options.linear == "no":
if (options.start == 0):
options.start = 0.49
if (options.multiplier < 0):
options.multiplier = math.exp(
(math.log(float(options.finish) / options.start)) /
options.limit)
print 'multiplier in use is', options.multiplier, 'and will scan from', options.start, 'to', options.finish
else:
adder = (float(options.finish) - options.start) / float(options.limit)
print 'will do linear scanning from', options.start, 'to', options.finish, "in ", options.limit, "steps and with adder of ", adder
# Connect to the daq system
daq = pydaq.Control(options.host, options.platform)
daq.connect()
print 'Partition is', daq.partition()
detectors = daq.detectors()
devices = daq.devices()
types = daq.types()
# print 'types are :\n', types
found = [False, False, False]
index = 0
for member in detectors:
if member == options.detector:
detectorValue = (index << 24) | ((options.detectorID & 0xff) << 16)
found[0] = True
index = index + 1
index = 0
for member in devices:
if member == options.device:
detectorValue = detectorValue | (index << 8) | (options.deviceID
& 0xff)
found[1] = True
index = index + 1
index = 0
for member in types:
if member == options.typeId:
typeIdValue = index | (options.typeIdVersion << 16)
found[2] = True
index = index + 1
if found[0] and found[1] and found[2]:
print "detector hex value", hex(detectorValue)
print 'typeId', hex(typeIdValue)
else:
if not found[0]:
print "Detector", options.detector, "not found!"
if not found[1]:
print "Device", options.device, "not found!"
if not found[2]:
print "Type", options.typeId, "not found!"
print "Exiting"
exit()
#
# First, get the current configuration key in use and set the value to be used
#
cdb = pycdb.Db(daq.dbpath())
key = daq.dbkey()
alias = daq.dbalias()
print 'Retrieved key ' + hex(key) + ' alias ' + alias
#
# Generate a new key with different epix and EVR configuration for each cycle
#
if options.dbalias == None:
newkey = cdb.clone(alias)
else:
newkey = cdb.clone(options.dbalias)
print 'Generated key ', hex(newkey)
print 'key', hex(key)
print 'detectorValue', hex(detectorValue)
print 'typeIdValue', hex(typeIdValue)
# xtcSet = cdb.get(key=key)
# print 'xtcSet members :\n'
# for member in xtcSet :
# for attr in dir(member) :
# print getattr(member,attr)
# print 'Done printing xtcSet\n'
# print "cdb.get opened\n", cdb.get(key=key)
xtc = cdb.get(key=key, src=detectorValue, typeid=typeIdValue)[0]
print 'xtc is', xtc
epix = xtc.get(0)
if set_dict(epix, options.parameter, float(options.start)) == False:
dump_dict(epix)
sys.exit(1)
else:
print 'Composing the sequence of configurations ...'
value = float(options.start)
cycleLength = 1
shutterActive = options.shutter != 'None'
if shutterActive:
cycleLength = 2
denom = float(options.limit + 1)
# mask = epix['AsicMask']
values = []
for cycle in range(options.limit + 1):
print cycle
index = float(cycle % (options.limit + 1)) + 1.0
set_dict(epix, options.parameter, value)
xtc.set(epix, cycle)
values.append(value)
if options.linear == "no":
# print cycle, int(round(value))
value = value * options.multiplier
else:
# print cycle, int(round(value))
value = value + adder
cdb.substitute(newkey, xtc)
cdb.unlock()
for cycle in range(len(values)):
print cycle, "value of", options.parameter, "is", values[cycle]
print ' done'
#
# Could scan EVR simultaneously
#
# evr = Evr .ConfigV4().read(cdb.xtcpath(key.value,Evr .DetInfo,Evr .TypeId))
# newxtc = cdb.remove_xtc(newkey,Evr.DetInfo,Evr.TypeId)
#
# Send the structure the first time to put the control variables
# in the file header
#
if options.use_l3t:
print "Acquiring %s events passing L3Trigger" % (options.events)
daq.configure(key=newkey,
l3t_events=options.events,
controls=[(options.parameter[0:29],
int(round(options.start)))])
else:
daq.configure(key=newkey,
events=options.events,
controls=[(options.parameter[0:29],
int(round(options.start)))])
print "Configured."
# set up shutter
if shutterActive:
ser = serial.Serial(options.shutter)
ser.write(chr(129)) ## close shutter
#
# Wait for the user to declare 'ready'
# Setting up monitoring displays for example
#
ready = raw_input('--Hit Enter when Ready-->')
for cycle in range(options.steps + 1):
if cycle % (options.limit + 1) == 0:
index = 0.0
subcycle = 0
if shutterActive:
ser.write(chr(129)) ## close shutter
print "Cycle", cycle, " closed -", options.parameter, "=", values[
subcycle]
else:
print "Cycle", cycle, "-", options.parameter, "=", values[
subcycle]
if options.use_l3t:
daq.begin(l3t_events=options.events,
controls=[(options.parameter[0:29], values[subcycle])
])
else:
daq.begin(controls=[(options.parameter[0:29],
values[subcycle])])
# wait for enabled , then enable the EVR sequence
# wait for disabled, then disable the EVR sequence
daq.end()
if shutterActive:
print " opened -", options.parameter, "=", values[
subcycle]
ser.write(chr(128)) ## open shutter
if options.use_l3t:
daq.begin(l3t_events=options.events,
controls=[(options.parameter[0:29],
values[subcycle])])
else:
daq.begin(controls=[(options.parameter[0:29],
values[subcycle])])
daq.end()
ser.write(chr(129)) ## close shutter
subcycle += 1
#
# Wait for the user to declare 'done'
# Saving monitoring displays for example
#
ready = raw_input('-- Finished, hit Enter to exit -->')
print 'Restoring key', hex(key)
daq.configure(key=key, events=1)
def init(self, controls=None, bDaqBegin=True):
while True:
fBeamFullRate = float(caget(pvBeamRate))
if fBeamFullRate == 0.5 or float(
int(fBeamFullRate)) == fBeamFullRate:
break
if not self.bSimMode:
if not (self.mccBurst.isLegalBeamRate(fBeamFullRate)):
print "!!! Beam rate %g is not stable, please wait for beam to stablize and run the script again" % (
fBeamFullRate)
return 1
self.mccBurst.mccBurstCheckInit()
if self.fBurstRate == -1:
self.fBurstRate = fBeamFullRate
if not (self.fBurstRate in dictRateToSyncMarker):
print "!!! Burst rate %g not supported" % (self.fBurstRate)
return 1
caput(pvPlayMode, 0) # PlayMode = Once
caput(pvMccSeqSyncMarker, dictRateToSyncMarker[self.fBurstRate])
caput(pvMccSeqBeamRequest,
0) # Set seuqencer rate to be 120Hz (TS4|TS1)
caget(pvMccSeqSyncMarker
) # caget bug: need to get twice to have latest value
print "\n## Beam rate = %g HZ, Sync marker = %g HZ" % (
fBeamFullRate, dictSyncMarkerToRate[int(
caget(pvMccSeqSyncMarker, bGetNumEnum=True))])
if not self.bSimMode:
if caget(pvBeamOwner) != caget(pvHutchId):
if self.fBurstRate == 60:
print "!!! Test Burst rate %g is not supported by MCC" % (
self.fBurstRate)
return 1
self.mccBurst.mccBurstSetRate(self.fBurstRate)
elif self.fBurstRate == fBeamFullRate:
self.mccBurst.mccBurstSetRate(0)
elif self.fBurstRate < fBeamFullRate:
if self.fBurstRate == 60:
print "!!! Burst rate %g is not supported by MCC" % (
self.fBurstRate)
return 1
self.mccBurst.mccBurstSetRate(self.fBurstRate)
else:
print "!!! Burst rate %g is faster than Beam rate %g" % (
self.fBurstRate, fBeamFullRate)
return 1
print "## Multiple shot: %d" % (self.iNumShot)
# Exposure Time =
# camear open (clean CCD) delay ( self.iSlowCamOpenDelay: 0 for PI, 5*120Hz for FLI)
# + manual sleep (fExpDelay)
# + exposure Time ((self.iNumShot / self.fBurstRate) second)
# = 0.0 + max(1, self.iSlowCamOpenDelay)/120.0 + (self.iNumShot / self.fBurstRate) + fExpDelay second
self.fExposureTime = 0.0 + self.iSlowCamOpenDelay / 120.0 + self.fExpDelay + self.iNumShot / float(
self.fBurstRate)
print "CREATE DAQ CONTROL OBJECT"
self.daq = pydaq.Control(self.daq_host, self.daq_platform)
try:
print "daq connect...",
sys.stdout.flush()
self.daq.connect() # get dbpath and key from DAQ
print " done."
except:
print "!! daq.connect() failed"
print "!! Possibly because 1. DAQ devices has NOT been allocated"
print "!! or 2. You are running DAQ control GUI in remote machines"
print "!! Please check 1. DAQ is in good state and re-select the devices"
print "!! 2. If the restart script actually runs DAQ in another machine"
print "ERROR", sys.exc_info()[0]
return 1
if self.bSimMode:
self.alias = "PRINCETON_SIM"
else:
self.alias = "SLOW_CAMERA"
if self.daq.dbalias() != self.alias:
print "!!! the current DAQ config type is %s" % (
self.daq.dbalias())
print "!!! please switch to %s to run this script" % (self.alias)
print "daq disconnect...",
sys.stdout.flush()
self.daq.disconnect()
print " done."
return 2
print "CONFIGURE DAQ"
if controls is None:
iFail = self.configure(controls=[])
else:
iFail = self.configure(controls=controls)
if iFail != 0:
print "daq disconnect...",
sys.stdout.flush()
self.daq.disconnect()
print " done."
return 3
if self.bShutterMode:
if ShutterInit(self.iNumShot) != 0:
print "Shutter Init Failed"
return 4
print "SET CAMERA CONTROL SEQUENCE"
self.setCameraControlSequence()
self.iNumTotalImage = 0
print "## Please make sure"
if not self.bSimMode:
print "## - MCC has switched to Burst Mode,"
print "## - Andor/Princeton camera is selected (if you need it),"
print "## - chiller is running and the cooling temperature is set properly."
if bDaqBegin:
# cpo changed this line
self.beginCycle(controls)
return 0
def _reinit_pydaq(self):
del self.daq
self.daq = pydaq.Control(host=self.host, platform=self.platform)
low = float(options.opts['from'])
high = float(options.opts['to'])
steps = int(options.opts['steps'])
events = int(options.opts['events'])
doOnce = False
if options.opts.has_key('once'):
doOnce = True
print 'Stepping %s from %f to %f with %d events at each of %d steps'%(motorpvname,low,high,events,steps)
if doOnce:
print '(once: stopping after one scan)
evtmask = pyca.DBE_VALUE | pyca.DBE_LOG | pyca.DBE_ALARM
# Initialize DAQ control
daq = pydaq.Control('sxr-daq')
# Let user setup plots
ready = raw_input('--Hit Enter when Ready-->')
# Configure DAQ
doRecord = False
if (options.opts['record'].upper()=='Y'):
doRecord = True
daq.configure(record=doRecord,
events=int(options.opts['events']),
controls=[(motorpvname,low)])
def scan_calibration(devtypes, options):
# if only a single device type was passed change to a list
if isinstance(devtypes, str):
devtypes = [devtypes]
if logger.isEnabledFor(logging.INFO):
logger.info('Detector pedestal/calibration script settings to use:')
logger.info(' host: %s', options.host)
logger.info(' platform: %s', options.platform)
logger.info(' dbalias: %s', options.dbalias)
logger.info(' devtypes: %s', devtypes)
if options.space > 7:
logger.warning('Space is too large, truncated to 7')
options.space = 7
logger.info(' space: %s', options.space)
logger.info(' Values: %s, %s', options.Value0, options.Value1)
logger.info(' darkEvents: %s', options.darkEvents)
logger.info(' events: %s', options.events)
logger.info(' userFlag: %s', options.userFlag)
logger.info(' cycleStart: %s', options.cycleStart)
logger.info(' cycleStop: %s', options.cycleStop)
logger.info(' fullCalib: %s', options.fullCalib)
logger.info(' record: %s', options.record)
logger.info(' simMode: %s', options.sim)
# configuration handlers for each detector
configs = {}
ncycles = 0
# Connect to the daq system
logger.debug('Connecting to the DAQ at %s with platform %d', options.host,
options.platform)
daq = pydaq.Control(options.host, options.platform)
daq.connect()
info = PartitionInfo(daq)
logger.debug('Current DAQ partition: %s', info.partition)
devices = info.find_devices(devtypes)
logger.info('Selected the following detectors to scan in the partition:')
max_label_size = daq.sizes().get('LabelNameSize')
logger.debug('Maximum allowed length of label names: %d', max_label_size)
for devtype, devs in sorted(devices.items()):
# only print devtype if there are devices of that type
if devs:
logger.info(' %s:', devtype)
for name, src in devs:
logger.info(' %s', name)
if devtype in DEVICE_CONFIG_HANDLERS:
handler = DEVICE_CONFIG_HANDLERS[devtype]
logger.debug(
'Creating configuration handler of type %s for %s',
handler.__name__, name)
configs[name] = handler(devtype,
name,
src,
options.space,
(options.Value0, options.Value1),
namesize=max_label_size)
# check which detector has the highest max_cycles/max_dark
if options.fullCalib:
if configs[name].max_cycle > ncycles:
ncycles = configs[name].max_cycle
else:
if configs[name].max_dark > ncycles:
ncycles = configs[name].max_dark
else:
logger.warning('Unsupported detector type: %s', devtype)
# select the default number of events for each cycle
nevents = [options.darkEvents] * ncycles
# prepare the database
key = daq.dbkey()
alias = daq.dbalias()
newkey = None
logger.info('Retrieved key %x with alias %s from the DAQ', key, alias)
# override the alias to use if one is passed to the script
if options.dbalias is not None:
logger.debug('Switching to user specified alias %s', options.dbalias)
alias = options.dbalias
with ConfigDB(daq.dbpath(), alias, sim=options.sim) as cdb:
logger.info('Cloned the alias %s to new key %x', cdb.alias, cdb.key)
logger.info('Composing the sequence of configurations ...')
for cycle in range(ncycles):
if cycle >= options.cycleStart and cycle < options.cycleStop:
for name, config in configs.items():
logger.debug("Creating cycle %d for %s", cycle, name)
if config.configure(cdb, cycle):
nevents[cycle] = options.events
# complete the database update
for name, config in configs.items():
logger.debug("Completing configuration for %s", name)
config.complete(cdb)
logger.info(' Done')
# save the value of the keyy before closing db
newkey = key if options.sim else cdb.key
try:
# Configure the DAQ and add pvlabels with scan metadata
cycle_labels = [(configs[name].scan_name, '')
for devs in devices.values() for name, _ in devs]
logger.debug(
"Configuring with key=%x, events=%d, labels=%s, record=%s", newkey,
options.events, cycle_labels, options.record)
if options.record is None:
daq.configure(key=newkey,
events=options.events,
labels=cycle_labels)
else:
daq.configure(key=newkey,
events=options.events,
labels=cycle_labels,
record=options.record)
logger.info("Configured.")
#
# Wait for the user to declare 'ready'
# Setting up monitoring displays for example
#
if options.userFlag > 0:
ready = input('--Hit Enter when Ready-->')
for cycle in range(ncycles):
if cycle >= options.cycleStart and cycle < options.cycleStop:
cycle_labels = []
logger.info('Scan info for calib cycle %d:', cycle)
logger.debug(' Number of events: %d', nevents[cycle])
for devs in devices.values():
for name, _ in devs:
scan_name = str(configs[name].scan_name)
cycle_name = str(configs[name].cycle_name(cycle))
cycle_labels.append((scan_name, cycle_name))
logger.info(' %s: %s', scan_name, cycle_name)
if not options.sim:
logger.debug(
'Starting calib cycle %d with events=%d, labels=%s',
cycle, nevents[cycle], cycle_labels)
daq.begin(events=nevents[cycle], labels=cycle_labels)
daq.wait()
logger.debug('Finished calib cycle %d', cycle)
#
# Wait for the user to declare 'done'
# Saving monitoring displays for example
#
if options.userFlag > 0:
ready = input('-- Finished, hit Enter to exit -->')
finally:
logger.info('Restoring key: %x', key)
daq.configure(key=key, events=1)
logger.debug('Disconnecting from the DAQ')
daq.disconnect()
