def _getProposalInput(self):
prop = self.proposalNum.text()
title = self.expTitle.text()
username = self.userName.text()
remark = self.remark.text()
proposaldir = self.proposalDir.text()
if proposaldir and not os.path.isdir(proposaldir):
QMessageBox.critical(
self, 'Error', 'The provided proposal path '
'does not exist!')
raise ConfigurationError('')
if not os.access(proposaldir, os.W_OK):
QMessageBox.critical(
self, 'Error', 'Don\'t have permission to '
'write in the proposal path! Please choose '
'a different one!')
raise ConfigurationError('')
try:
useremail = mailaddress(self.userEmail.text())
except ValueError:
QMessageBox.critical(
self, 'Error', 'The user email entry is '
'not a valid email address')
raise ConfigurationError('') from None
return prop, title, username, useremail, proposaldir, remark
def doInit(self, mode):
self.valuetype = oneof(*sorted(self.presets, key=num_sort))
self._waitdevs = []
self._aliases = {}
self._devpos = {}
for setting, values in self.presets.items():
values = dict(values)
try:
self._aliases[setting] = (values.pop('active_ap'),
values.pop('active_x'),
values.pop('active_y'))
except KeyError:
raise ConfigurationError(
self, 'setting %r needs active_ap, active_x and active_y '
'settings' % setting) from None
try:
for name in self._aliases[setting]:
session.getDevice(name)
except NicosError as exc:
raise ConfigurationError(
self,
'could not create/find alias targets for setting %r' %
setting) from exc
for key in values:
if key not in self.alloweddevs:
raise ConfigurationError(
self, 'device %s is not allowed '
'to be moved by sample_pos' % key)
self._devpos[setting] = values
def doWriteRange(self, r):
rmin, rmax = r
umin, umax = self._attached_moveable.userlimits
if rmin > rmax:
raise ConfigurationError(self, 'minimum (%s) above the maximum '
'(%s)' % (rmin, rmax))
if rmin < umin - abs(umin * 1e-12):
raise ConfigurationError(self, 'minimum (%s) below the moveable '
'minimum (%s)' % (rmin, umin))
if rmax > umax + abs(umax * 1e-12):
raise ConfigurationError(self, 'maximum (%s) above the moveable '
'maximum (%s)' % (rmax, umax))
def doPreinit(self, mode):
BaseImageChannel.doPreinit(self, mode)
if mode != SIMULATION:
if self._getProperty('compact_readout') != 'True':
raise ConfigurationError(self, 'server must be set to '
'compact readout mode')
if len(eval(self._getProperty('compact_foil_start'))) != \
len(self.foilsorder):
raise ConfigurationError(self, 'number of foils to read '
'out from server does not match '
'with "foilsorder" parameter')
self._perfoil = int(self._getProperty('compact_per_foil'))
def doInit(self, mode):
MappedMoveable.doInit(self, mode)
for k, t in self.mapping.items():
if len(t) != len(self.devices):
raise ConfigurationError(self, 'Switcher state entry for key '
'%r has different length than '
'moveables list' % k)
if self.precision:
if len(self.precision) not in [1, len(self.devices)]:
raise ConfigurationError(self, 'The precision list must either'
' contain only one element or have '
'the same amount of elements as the '
'moveables list')
def doReadRange(self):
# check range against moveable user limits
if 'range' in self._config:
amin, amax = self._config['range']
mmin, mmax = self._attached_moveable.userlimits
if amin < mmin:
raise ConfigurationError(self, 'min (%s) below the moveable'
' min (%s)' % (amin, mmin))
if amax > mmax:
raise ConfigurationError(self, 'max (%s) above the moveable'
' max (%s)' % (amax, mmax))
else:
amin, amax = self._attached_moveable.userlimits
return amin, amax
def doReadAbslimits(self):
mot_amin, mot_amax = self._attached_motor.abslimits
# if abslimits are configured, use them, but they can only restrict,
# not widen, the motor's abslimits
if 'abslimits' in self._config:
amin, amax = self._config['abslimits']
if amin < mot_amin - abs(mot_amin * 1e-12):
raise ConfigurationError(self, 'abslimits: min (%s) below '
"motor's min (%s)" % (amin, mot_amin))
if amax > mot_amax + abs(mot_amax * 1e-12):
raise ConfigurationError(self, 'abslimits: max (%s) above '
"motor's max (%s)" % (amax, mot_amax))
else:
amin, amax = mot_amin, mot_amax
return amin, amax
def doInit(self, mode):
if self.reflimits is not None:
if not (0 <= self.reflimits[0] <= self.reflimits[1] <=
self.reflimits[2]):
raise ConfigurationError(
self, 'reflimits must be in ascending'
' order!')
def __get_param(self, attrname):
# take first match
tubeval = getattr(self._attached_tube, attrname)
stickval = getattr(self._attached_stick, attrname)
if tubeval == stickval:
res = tubeval
else:
self.log.warning(
'%s.%s (%r) != %s.%s (%r), please set %s.%s to '
'the desired value!', self._attached_tube.name, attrname,
tubeval, self._attached_stick.name, attrname, stickval,
self.name, attrname)
# try to take the 'more important' one
if self._attached_stick.target is not None and \
self._attached_stick.target > self._attached_tube.absmax:
res = stickval
else:
if self.regulationmode == 'stick':
res = stickval
elif self.regulationmode == 'tube':
res = tubeval
else:
raise ConfigurationError(
self, 'Parameters %s.%s and %s.%s'
' differ! please set them using '
'%s.%s only.' % (self._attached_tube.name, attrname,
self._attached_stick.name, attrname,
self.name, attrname))
self.log.debug('param %s is %r', attrname, res)
return res
def doInit(self, mode):
# import server and serializer class
servercls = importString(self.servercls)
serialcls = importString(self.serializercls)
self._stoprequest = False
# the controller represents the internal script execution machinery
if self.autosimulate and not config.sandbox_simulation:
raise ConfigurationError('autosimulation configured but sandbox'
' deactivated')
self._controller = ExecutionController(self.log, self.emit_event,
'startup', self.simmode,
self.autosimulate)
# cache log messages emitted so far
self._messages = []
host, port = parseHostPort(self.server, DEFAULT_PORT)
# create server (transport + serializer)
self._server = servercls(self, (host, port), serialcls())
self._watch_worker = createThread('daemon watch monitor',
self._watch_entry)
def doUpdateCounter(self, name):
for (i, value) in enumerate(self._attached_detector.valueInfo()):
if value.name == name:
self._vindex = i
break
else:
raise ConfigurationError(self, "Counter '%s' not present" % name)
def doInit(self, mode):
MultiSwitcher.doInit(self, mode)
if len(self._attached_moveables) != 5:
raise ConfigurationError(self, 'must have exactly 5 moveables')
self._mot_rot, self._mot_xv, self._mot_yv, self._mot_xh, \
self._mot_yh = self._attached_moveables
self.valuetype = oneof(*sorted(self.mapping, key=num_sort))
def doInit(self, mode):
self.valuetype = oneof(*sorted(self.mapping, key=num_sort))
if len(self._attached_slits) != len(self.slitpos):
raise ConfigurationError(
self, 'number of elements in slitpos '
'parameter must match number of attached '
'slit devices')
def doInit(self, mode):
if '.raw' not in self.filenametemplate[0]:
raise ConfigurationError(
self, 'first filenametemplate must '
'contain .raw which is then exchanged '
'to .header and .log for additional '
'data files')
def _getRaw(self):
if parse is None:
raise NicosError(
self, 'cannot parse web page, lxml is not '
'installed on this system')
url = 'http://%s/web?group=%d' % (self.hostname, self.group)
try:
tree = parse(url)
names = [
name.text.strip()
for name in tree.findall('//font[@class="tagname"]')
]
values = [
value.text.strip()
for value in tree.findall('//font[@class="pv"]')
]
info = dict(zip(names, values))
if self.valuename not in info:
raise ConfigurationError(
self, 'value %r not found on '
'Memograph page (valid values are %s)' %
(self.valuename, ', '.join(map(repr, names))))
return info[self.valuename]
except ConfigurationError: # pass through error raised above
raise
except Exception as err:
raise CommunicationError(
self, 'Memograph not responding or '
'changed format: %s' % err)
def set(self, number, parameters):
for key in ('name', 'aperture', 'position', 'timefactor', 'thickness',
'detoffset', 'comment'):
if key not in parameters:
raise ConfigurationError(
self, 'missing key %r in sample entry' % key)
Sample.set(self, number, parameters)
def doPreinit(self, mode):
# Don't create PVs in simulation mode
self._pvs = {}
self._pvctrls = {}
if mode != SIMULATION:
# in case we get started in a thread, make sure to use the global
# CA context in that thread
if epics.ca.current_context() is None:
epics.ca.use_initial_context()
# When there are standard names for PVs (see motor record), the PV
# names may be derived from some prefix. To make this more flexible,
# the pv_parameters are obtained via a method that can be overridden
# in subclasses.
pv_parameters = self._get_pv_parameters()
for pvparam in pv_parameters:
# Retrieve the actual PV-name from (potentially overridden) method
pvname = self._get_pv_name(pvparam)
if not pvname:
raise ConfigurationError(self, 'PV for parameter %s was '
'not found!' % pvparam)
pv = self._pvs[pvparam] = epics.pv.PV(
pvname, connection_timeout=self.epicstimeout)
pv.connect()
if not pv.wait_for_connection(timeout=self.epicstimeout):
raise CommunicationError(self, 'could not connect to PV %r'
% pvname)
self._pvctrls[pvparam] = pv.get_ctrlvars() or {}
else:
for pvparam in self._get_pv_parameters():
self._pvs[pvparam] = HardwareStub(self)
self._pvctrls[pvparam] = {}
def doInit(self, mode):
# switch off watchdog, important before doing any write access
if mode != SIMULATION:
self._dev.WriteOutputWord((WATCHDOG_REGISTER, WATCHDOG_DISABLE))
# check 'dwordorder' is 'little'
if self._getProperty('dwordorder') != 'little':
raise ConfigurationError("dwordorder property must "
"be set to 'little'!")
def doInit(self, mode):
if self.fallback in self.mapping:
raise ConfigurationError(
self, 'Value of fallback parameter is '
'not allowed to be in the mapping!')
self._inverse_mapping = {}
for k, v in self.mapping.items():
self._inverse_mapping[v] = k
def _resolve_block(self, block):
# exchange SetupBlock objects by their definition, or raise
# a ConfigurationError if it doesn't exist.
if not isinstance(block, SetupBlock):
return block
setup, bname = block._setupname, block._blockname
setupinfo = session.getSetupInfo()
if setup not in setupinfo:
raise ConfigurationError(
self, 'Setup "%s" required by '
'SetupBlock() does not exist' % setup)
blocks = setupinfo[setup]['monitor_blocks']
if bname not in blocks:
raise ConfigurationError(
self, 'Setup "%s" does not define a '
'monitor block called "%s"' % (setup, bname))
return blocks[bname]
def doWriteTimeconstant(self, value):
if value not in TIMECONSTANTS:
raise ConfigurationError(self, 'invalid time constant, valid ones '
'are ' + ', '.join(map(str, TIMECONSTANTS)))
value = TIMECONSTANTS.index(value)
self._dev.WriteLine('OFLT %d' % value)
if self.doReadTimeconstant() != value:
raise NicosError(self, 'setting new time constant failed')
def doWriteRatio(self, value):
if self._attached_ratio:
if not self.isMaster:
self._attached_ratio.start(value)
else:
raise UsageError(
'I am a master, ask my slave to set its ratio')
else:
raise ConfigurationError('No device attached to set the ratio')
def doWritePhase(self, value):
if self._attached_phase:
if not self.isMaster:
self._attached_phase.start(value)
else:
raise UsageError(
'I am a master, ask my slave to set its phase')
else:
raise ConfigurationError('No device attached to set the phase')
def doWriteSpeed(self, value):
if self._attached_speed:
if self.isMaster:
self._attached_speed.start(value)
else:
raise UsageError(
'A slave cannot set speed. Please ask my master')
else:
raise ConfigurationError('No device attached to set the speed')
def doInit(self, mode):
if mode != SIMULATION:
if self._attached_stick is None or self._attached_tube is None:
raise ConfigurationError(
self, 'Both stick and tube needs to '
'be set for this device!')
absmin = min(self._attached_tube.absmin,
self._attached_stick.absmin)
absmax = self._attached_stick.absmax
self._setROParam('abslimits', (absmin, absmax))
def __init__(self):
try:
if not session.experiment or not session.experiment.propdb:
credpath = path.join(path.expanduser('~'), '.nicos',
'credentials')
credentials = readFile(credpath)
else:
credentials = readFile(session.experiment.propdb)
except IOError as e:
raise ConfigurationError('Can\'t read credentials '
'for propdb-access from file: %s' % e)
credentials = credentials[0]
try:
self.user, hostdb = credentials.split('@')
self.host, self.db = hostdb.split(':')
except ValueError:
raise ConfigurationError('%r is an invalid credentials string '
'("user@host:dbname")' % credentials)
if DB is None:
raise ConfigurationError('MySQL adapter is not installed')
def doInit(self, mode):
if mode == SIMULATION:
return
intype = FTYPE_TO_VALUETYPE.get(self._pvs['readpv'].ftype, anytype)
outtype = FTYPE_TO_VALUETYPE.get(self._pvs['writepv'].ftype, anytype)
if intype != self.valuetype:
raise ConfigurationError(self, 'Input PV %r does not have the '
'correct data type' % self.readpv)
if outtype != self.valuetype:
raise ConfigurationError(self, 'Output PV %r does not have the '
'correct data type' % self.writepv)
if self.targetpv:
target_type = FTYPE_TO_VALUETYPE.get(
self._pvs['targetpv'].ftype, anytype)
if target_type != self.valuetype:
raise ConfigurationError(
self, 'Target PV %r does not have the '
'correct data type' % self.targetpv)
def doPreinit(self, mode):
if mode != SIMULATION:
host, port = self.host.split(':')
self._client = ControlClient(host, port)
remote_objects = self._client.get_object_collection()
if self.remoteobj not in remote_objects.keys():
raise ConfigurationError('No such object on {}: {}'.format(
self.host, self.remoteobj))
self._obj = remote_objects[self.remoteobj]
def doInit(self, session_mode):
Detector.doInit(self, session_mode)
self._img = self._attached_images[0]
if session_mode == MASTER:
if not self._attached_images or \
not isinstance(self._attached_images[0], (KWSImageChannel,
VirtualKWSImageChannel)):
raise ConfigurationError(
self, 'KWSDetector needs a KWSChannel '
'as attached image')
self.kwscounting = False
def doInit(self, mode):
if self.__class__ is CacheDatabase:
raise ConfigurationError(
'CacheDatabase is abstract, use a derived device class')
self._lock_lock = threading.Lock()
self._locks = {}
self._rewrite_lock = threading.Lock()
# map incoming prefix -> set of new prefixes
self._rewrites = {}
# map new prefix -> incoming prefix
self._inv_rewrites = {}
