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