def setUB(ub_name, diffractometer_geometry, lattice_geometry, a, b, c, alpha, beta, gamma, hardware_positions_1,
hardware_positions_2, reflection_1, reflection_2):
hardware = DummyHardwareAdapter(('delta', 'theta', 'chi', 'phi', 'mu', 'gamma'))
en = hardware.energy
if diffractometer_geometry == 'SixCircle':
dc = create_diffcalc('you', SixCircle(), hardware)
else:
raise ValueError('Geometry not supported')
#Create new ub calculation
dc.ub.newub(ub_name)
#Setup lattice
dc.ub.setlat(lattice_geometry, int(a), int(b), int(c), int(alpha), int(beta), int(gamma))
#Calculate two_theta (not necessary but used for demo purposes)
#Setup hardware position and reflections to map the transformation
hardware.position = hardware_positions_1
dc.ub.addref(reflection_1)
dc.ub.addref(reflection_2, hardware_positions_2, en)
dc.ub.ub()
dc.checkub()
return dc
def dummySetup(self, name, geometry, engine, tag, author):
self.setName(name)
self.setEngine(engine=engine)
self.setGeometry(geometry)
self.setTag(tag)
self.setAuthor(author)
self.setAnglesforHardware(angleList=self.getangleList(), Geometry=geometry)
self.setHardwareAdapter(hardwareAdapter='DummyHardwareAdapter')
self._diffractometer = create_diffcalc(engine, geometry=self._geometry, hardware=self._hardware)
def setUp(self):
self.geometry = SixCircleGammaOnArmGeometry()
self.hardware = DummyHardwareAdapter(
('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
self.d = create_diffcalc('vlieg', self.geometry, self.hardware, True,
UbCalculationNonPersister())
self.d.raiseExceptionsForAllErrors = True
#self.scenarios = scenarios.sessions()
self.setSessionAndCalculation()
prepareRawInput([])
def create_diffractometer(diffractometer_geometry):
"""
Create a diffractometer object in order to perform reciprocal space calculations
:param diffractometer_geometry: SixCircle or FourCircle
:return: diffcalc.diffcalc object
"""
hardware = DummyHardwareAdapter(('delta', 'theta', 'chi', 'phi', 'mu', 'gamma'))
if diffractometer_geometry == 'SixCircle':
dc = create_diffcalc('you', SixCircle(), hardware)
else:
raise ValueError('Geometry not supported')
return dc
def setup(self):
axis_names = ("mu", "delta", "nu", "eta", "chi", "phi")
# virtual_angles = ('theta', 'qaz', 'alpha', 'naz', 'tau', 'psi', 'beta')
hardware = DummyHardwareAdapter(axis_names)
geometry = diffcalc.hkl.you.geometry.SixCircle()
self.dc = create_diffcalc(
engine_name="you",
geometry=geometry,
hardware=hardware,
raise_exceptions_for_all_errors=True,
ub_persister=UbCalculationNonPersister(),
)
def demo_setup():
global hardware, dc
print "\n>>> from diffcalc.hkl.you.geometry import SixCircle"
from diffcalc.hkl.you.geometry import SixCircle
print "\n>>> from diffcalc.hardware import DummyHardwareAdapter"
from diffcalc.hardware import DummyHardwareAdapter
print "\n>>> from diffcalc.diffcalc_ import create_diffcalc"
from diffcalc.diffcalc_ import create_diffcalc
print "\n>>> hardware = DummyHardwareAdapter(('mu', 'delta', 'gam', 'eta', 'chi', 'phi'))"
hardware = DummyHardwareAdapter(('mu', 'delta', 'gam', 'eta', 'chi', 'phi'))
print "\n>>> dc = create_diffcalc('you', SixCircle(), hardware)"
dc = create_diffcalc('you', SixCircle(), hardware)
def setUp(self):
self.en = DummyPD('en')
dummy = createDummyAxes(['alpha', 'delta', 'omega', 'chi', 'phi'])
group = ScannableGroup('fivecgrp', dummy)
self.fivec = DiffractometerScannableGroup('fivec', None, group)
self.d = create_diffcalc('vlieg', Fivec(),
ScannableHardwareAdapter(self.fivec, self.en),
True, UbCalculationNonPersister())
self.d.raiseExceptionsForAllErrors = True
self.fivec.diffcalc = self.d
self.hkl = Hkl('hkl', self.fivec, self.d)
self.hklverbose = Hkl('hkl', self.fivec, self.d,
('theta', '2theta', 'Bin', 'Bout', 'azimuth'))
self.orient()
def basicSetup(self, hardwareAdapter, **params):
'''
Sets up a basic diffractometer with default values. These values can be changed by using native functions such as
someAngle.setName(),someAngle.setpositive () can be used. If this is not the preference as this requires setting up too many parameters,
diffcalc.config.advancedSetup() provides a cleaner/more organized way to set up a custom diffractometer by utilizing dictionaries.
self.engine=engine
self.tag='Basic diffractometer configuration'
self.author='default'
self.defaultAngleParam={'value':0,
'geometry':SixCircle(),
'positiveLimit':180,
'negativeLimit':-180}
parameterList={'angles','geometry'}
'''
self._tag = 'Basic diffractometer configuration'
parameterList = {'angles', 'geometry'}
self.defaultAngleParam = {'value': 0,
'geometry': SixCircle(),
'positiveLimit': 180,
'negativeLimit': -180}
for param in params:
if param not in parameterList:
logInstance.logger.info('Parameter "' + str(param) + '" not supported by reciprocalSetup()')
raise ValueError('Parameter "' + str(param) + '" not supported by reciprocalSetup()')
if 'angles' not in params:
if self._geometry == 'SixCircle':
angleList = {'mu', 'delta', 'gam', 'eta', 'chi', 'phi'}
else:
angleList = {'mu', 'delta', 'nu', 'eta'}
else:
angleList = params['angles']
if 'geometry' in params:
self._geometry = params['geometry']
if self._geometry == 'SixCircle' or self._geometry == 'FourCircle':
if self._geometry == 'SixCircle':
self._geometry = SixCircle()
else:
self._geometry = FourCircle()
else:
logInstance.logger.info('Please enter a valid geometry')
raise ValueError('Please enter a valid geometry')
self.setAnglesforHardware(angleList)
self.setHardwareAdapter(hardwareAdapter)
self._diffractometer = create_diffcalc(engine_name=self._engine, geometry=self._geometry,
hardware=self._hardware)
def createDiffcalcAndScannables(self):
self.en = DummyPD('en')
dummy = createDummyAxes(['delta', 'omega', 'chi', 'phi'])
scannableGroup = ScannableGroup('fourcgrp', dummy)
self.fourc = DiffractometerScannableGroup(
'fourc', None, scannableGroup)
hwmp = ScannableHardwareAdapter(self.fourc, self.en)
self.d = create_diffcalc('vlieg',
Fourc(),
hwmp,
True,
UbCalculationNonPersister())
self.fourc.diffcalc = self.d
self.hkl = Hkl('hkl', self.fourc, self.d)
self.d.raiseExceptionsForAllErrors = True
def createDiffcalcAndScannables(self, geometryClass):
self.en = DummyPD('en')
dummy = createDummyAxes(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
group = ScannableGroup('sixcgrp', dummy)
self.sixc = DiffractometerScannableGroup('sixc', None, group)
self.d = create_diffcalc(
'vlieg',
geometryClass(),
ScannableHardwareAdapter(self.sixc, self.en),
True,
UbCalculationNonPersister())
self.sixc.diffcalc = self.d
self.hkl = Hkl('hkl', self.sixc, self.d)
self.d.raiseExceptionsForAllErrors = True
def setDCInstance(self):
'''
To be modified as the hardware adapter is initiated
'''
self._diffractometer = create_diffcalc(str(self._engine), geometry=self._geometry, hardware=self._hardware)
logInstance.logger.info('DiffCalc diffractometer instance created')
def create_objects(
dummy_axis_names=None, # list of strings
axis_scannable_list=None, # list of single axis scannables
axes_group_scannable=None, # single scannable group
dummy_energy_name=None,
energy_scannable=None,
energy_scannable_multiplier_to_get_KeV=1,
geometry=None, # instance or name
hkl_name='hkl',
hkl_virtual_angles_to_report=(),
hklverbose_name='hklverbose',
hklverbose_virtual_angles_to_report=('2theta', 'Bin', 'Bout', 'azimuth'),
diffractometer_scannable_name=None, # e.g. SixCircleGammaOnArmGeometry.
# or determined by geometry
demo_commands=[],
simulated_crystal_counter_name=None,
engine_name='vlieg',
raise_exceptions_for_all_errors=True):
if VERBOSE:
print "=" * 80
objects = {}
if engine_name.lower() not in AVAILABLE_ENGINES:
raise KeyError("The engine '%s' was not recognised. "
"Try %r" % (engine_name, AVAILABLE_ENGINES))
# Obtain geometry instance
if engine_name.lower() == 'vlieg':
geometry = _determine_vlieg_geometry(geometry)
elif engine_name.lower() == 'you':
geometry = _determine_you_geometry(geometry)
else:
raise ValueError()
# Create diffractometer scannable and possibly dummy axes
diffractometer_scannable_name = _determine_diffractometer_scannable_name(
diffractometer_scannable_name, geometry)
objects.update(_create_diff_and_dummies(dummy_axis_names,
axis_scannable_list,
axes_group_scannable,
diffractometer_scannable_name))
diff_scannable = objects[diffractometer_scannable_name]
# Create dummy energy (if needed) and wavelength scannable
objects_, energy_scannable = _create_wavelength_and_energy(
dummy_energy_name, energy_scannable,
energy_scannable_multiplier_to_get_KeV)
objects.update(objects_)
# Create hardware adapter
hardware = ScannableHardwareAdapter(diff_scannable, energy_scannable,
energy_scannable_multiplier_to_get_KeV)
# Instantiate diffcalc
dc = create_diffcalc(engine_name.lower(),
geometry,
hardware,
raise_exceptions_for_all_errors,
UBCalculationPersister())
objects['dc'] = dc
diff_scannable.diffcalc = dc
# Create hkl, h, k and l scannables
objects.update(
_create_hkl(hkl_name, diff_scannable, dc,
hkl_virtual_angles_to_report))
# Create verbose hkl
objects.update(
_create_hkl_verbose(hklverbose_name, diff_scannable, dc,
hklverbose_virtual_angles_to_report))
# Create parameter/constraint scannables
objects.update(_create_constraint_scannables(dc))
if engine_name.lower() == 'you':
objects['a_eq_b'] = 'a_eq_b'
# Create simulated crystal counter
if simulated_crystal_counter_name:
ct = SimulatedCrystalCounter(simulated_crystal_counter_name,
diff_scannable, geometry, objects['wl'])
ct.level = 10
objects.update({ct.name: ct})
if VERBOSE:
print "\nCreated Simulated Crystal Counter:\n ", ct.name
# expose and alias ub and hkl commands from diffcalc object
if VERBOSE:
print "UB"
print "=="
objects.update(_expose_and_alias_commands(dc.ub.commands))
if VERBOSE:
print "hkl"
print "==="
objects.update(_expose_and_alias_commands(dc.hkl.commands))
if VERBOSE:
print "Tutorial"
print ""
if demo_commands:
objects.update(_create_and_alias_diffcalcdemo(demo_commands))
if engine_name.lower() == 'vlieg':
# add strings for transformX commands
objects.update(
{'on': 'on', 'off': 'off', 'auto': 'auto', 'manual': 'manual'})
if VERBOSE:
print "=" * 80
objects['ub'].im_func.__doc__ = format_command_help(dc.ub.commands)
Hkl.dynamic_docstring = format_command_help(dc.hkl.commands)
print "-" * 80
print "For help type 'help ub' and 'help hkl'."
print "-" * 80
return objects
