def setup_method(self): self.diff = MockScannable() self.wl = MockScannable() self.wl.pos = 1. self.eq = MockEquation() self.scc = SimulatedCrystalCounter('det', self.diff, Fourc(), self.wl, self.eq)
class TestSimulatedCrystalCounter(unittest.TestCase): def setUp(self): self.diff = MockScannable() self.wl = MockScannable() self.wl.pos = 1. self.eq = MockEquation() self.scc = SimulatedCrystalCounter('det', self.diff, Fourc(), self.wl, self.eq) def testInit(self): self.assertEquals(list(self.scc.getInputNames()), ['det_count']) self.assertEquals(list(self.scc.getExtraNames()), []) self.assertEquals(self.scc.chiMissmount, 0.) self.assertEquals(self.scc.phiMissmount, 0.) def testCalcUB(self): UB = matrix([[2 * pi, 0, 0], [0, 2 * pi, 0], [0, 0, 2 * pi]]) mneq_(self.scc.UB, UB) def testGetHkl(self): self.diff.pos = [60, 30, 0, 0] hkl = self.scc.getHkl() self.assert_(nearlyEqual(hkl, (1, 0, 0), .0000001), "%s!=\n%s" % (hkl, (1, 0, 0))) self.diff.pos = [60, 31, 0, 0] hkl = self.scc.getHkl() self.assert_(nearlyEqual(hkl, (0.999847695156391, 0.017452406437283574, 0), .0000001), "%s!=\n%s" % (hkl, (1, 0, 0))) def testGetPosition(self): self.diff.pos = [60, 30, 0, 0] self.scc.asynchronousMoveTo(2) count = self.scc.getPosition() self.assert_(nearlyEqual(self.eq.dHkl, (0, 0, 0), .00001)) self.assertEqual(count, 2) self.diff.pos = [60, 31, 0, 0] count = self.scc.getPosition() dHkl = (0.999847695156391 - 1, .017452406437283574, 0) self.assert_(nearlyEqual(self.eq.dHkl, dHkl, .00001), "%s!=\n%s" % (self.eq.dHkl, dHkl)) self.assertEqual(count, 2) def test__repr__(self): self.diff.pos = [60, 30, 0, 0] print self.scc.__repr__()
def usesim(): # sample chamber print '- setting hkl ---> hkl_sim' print '- en ---> simenergy' global settings settings.hardware = _hw_sim settings.energy_scannable = simenergy settings.axes_scannable_group = _sim_fourc # Create diffractometer scannable import __main__ _diff_scn_name = settings.geometry.name from diffcalc.dc import dcyou as _dc _diff_scn = DiffractometerScannableGroup(_diff_scn_name, _dc, _sim_fourc) hkl_sim = Hkl('hkl_sim', _sim_fourc, DiffractometerYouCalculator(_hw_sim, settings.geometry)) __main__.hkl = hkl_sim __main__.h = hkl_sim.h __main__.k = hkl_sim.k __main__.l = hkl_sim.l setLimitsAndCuts(simtth, simth, simchi, simalpha) __main__.fourc = _diff_scn from diffcalc.gdasupport.you import _virtual_angles __main__.hklverbose = Hkl('hklverbose', __main__.fourc, _dc, _virtual_angles) if GDA: __main__.en = simenergy __main__.wl = Wavelength('wl', __main__.en, ESMTGKeV) # @UndefinedVariable __main__.ct = SimulatedCrystalCounter( 'ct', __main__.fourc, settings.geometry, __main__.wl) # @UndefinedVariable
def usepoint(): print '- setting hkl ---> hkl_point' global settings settings.hardware = _hw settings.energy_scannable = pgm_energy settings.axes_scannable_group = _fourc # Create diffractometer scannable from diffcalc.dc import dcyou as _dc _diff_scn = DiffractometerScannableGroup(settings.geometry.name, _dc, _fourc) setLimitsAndCuts(tth, th, chi, phi) import __main__ __main__.hkl = hkl_point __main__.h = hkl_point.h __main__.k = hkl_point.k __main__.l = hkl_point.l __main__.fourc = _diff_scn from diffcalc.gdasupport.you import _virtual_angles __main__.hklverbose = Hkl('hklverbose', __main__.fourc, _dc, _virtual_angles) if GDA: __main__.en = pgm_energy __main__.wl = Wavelength('wl', __main__.en, ESMTGKeV) # @UndefinedVariable __main__.ct = SimulatedCrystalCounter( 'ct', __main__.fourc, settings.geometry, __main__.wl) # @UndefinedVariable
def swithMotors(delta, mu, eta, chi, phi): import __main__ from diffcalc.dc import dcyou as _dc ### update Wrap i21 names to get diffcalc names _fourc = ScannableGroup('_fourc', (delta, mu, eta, chi, phi)) #update diffcalc objects __main__.settings.hardware = ScannableHardwareAdapter( _fourc, __main__.en, ESMTGKeV) # @UndefinedVariable __main__.settings.geometry = diffcalc.hkl.you.geometry.FourCircle( ) # @UndefinedVariable __main__.settings.energy_scannable = __main__.en # @UndefinedVariable __main__.settings.axes_scannable_group = _fourc __main__.settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV __main__.fourc = DiffractometerScannableGroup('fourc', _dc, _fourc) __main__.hkl = Hkl('hkl', _fourc, _dc) __main__.h, __main__.k, __main__.l = hkl.h, hkl.k, hkl.l from diffcalc.gdasupport.you import _virtual_angles from diffcalc.gdasupport.scannable.simulation import SimulatedCrystalCounter from diffcalc.gdasupport.scannable.wavelength import Wavelength __main__.hklverbose = Hkl('hklverbose', _fourc, _dc, _virtual_angles) __main__.wl = Wavelength('wl', __main__.en, ESMTGKeV) # @UndefinedVariable __main__.ct = SimulatedCrystalCounter( 'ct', _fourc, __main__.settings.geometry, __main__.wl) # @UndefinedVariable
def setUp(self): self.diff = MockScannable() self.wl = MockScannable() self.wl.pos = 1. self.eq = MockEquation() self.scc = SimulatedCrystalCounter('det', self.diff, Fourc(), self.wl, self.eq)
def swithMotors(sax, say, saz, sath, sachi, saphi, diodedelta, specm5tth): import __main__ __main__.xyz_eta = ScannableGroup('xyz_eta', [sax, say, saz]) # @UndefinedVariable #update support for i21 non-concentric rotation motions __main__.sa = I21SampleStage('sa', sath, sachi, saphi,__main__.xyz_eta) # @UndefinedVariable __main__.tp_phi = sa.tp_phi_scannable __main__.tp_lab = I21TPLab('tp_lab', __main__.sa) # @UndefinedVariable __main__.tp_labx = __main__.tp_lab.tp_labx # @UndefinedVariable __main__.tp_laby = __main__.tp_lab.tp_laby # @UndefinedVariable __main__.tp_labz = __main__.tp_lab.tp_labz # @UndefinedVariable ### update Wrap i21 names to get diffcalc names _fourc = I21DiffractometerStage('_fourc', diodedelta, __main__.sa) # @UndefinedVariable __main__.delta = _fourc.delta __main__.eta = _fourc.eta __main__.chi = _fourc.chi __main__.phi = _fourc.phi #update diffcalc objects __main__.settings.hardware = ScannableHardwareAdapter(_fourc, __main__.en, ESMTGKeV) # @UndefinedVariable __main__.settings.geometry = FourCircleI21(beamline_axes_transform=beamline_axes_transform) # @UndefinedVariable __main__.settings.energy_scannable = __main__.en # @UndefinedVariable __main__.settings.axes_scannable_group= _fourc __main__.settings.energy_scannable_multiplier_to_get_KeV = ESMTGKeV __main__.fourc=DiffractometerScannableGroup('fourc', _dc, _fourc) __main__.hkl = Hkl('hkl', _fourc, _dc) __main__.h, __main__.k, __main__.l = hkl.h, hkl.k, hkl.l from diffcalc.gdasupport.you import _virtual_angles from diffcalc.gdasupport.scannable.simulation import SimulatedCrystalCounter from diffcalc.gdasupport.scannable.wavelength import Wavelength __main__.hklverbose = Hkl('hklverbose', _fourc, _dc, _virtual_angles) __main__.wl = Wavelength('wl',__main__.en,ESMTGKeV) # @UndefinedVariable __main__.ct = SimulatedCrystalCounter('ct', _fourc, __main__.settings.geometry,__main__.wl) # @UndefinedVariable #update scannales: fourc_vessel & hkl_vessel' _fourc_vessel = ScannableGroup('_fourc', (delta, th, chi, phi)) #I21DiffractometerStage('_fourc_vessel', m5tth, sa) __main__.fourc_vessel = DiffractometerScannableGroup('fourc_vessel', _dc, _fourc_vessel) __main__.hkl_vessel = Hkl('hkl_vessel', _fourc_vessel, _dc) __main__.h_vessel, __main__.k_vessel, __main__.l_vessel = hkl_vessel.h, hkl_vessel.k, hkl_vessel.l #Update scannables: fourc_lowq & hkl_lowq' _fourc_lowq = ScannableGroup('_fourc', (delta, th, chi, phi)) #I21DiffractometerStage('_fourc_lowq', m5tth, sa,delta_offset=LOWQ_OFFSET_ADDED_TO_DELTA_WHEN_READING) __main__.fourc_lowq = DiffractometerScannableGroup('fourc_lowq', _dc, _fourc_lowq) __main__.hkl_lowq = Hkl('hkl_lowq', _fourc_lowq, _dc) __main__.h_lowq, __main__.k_lowq, __main__.l_lowq = hkl_lowq.h, hkl_lowq.k, hkl_lowq.l #Update scannables: fourc_highq & hkl_highq' _fourc_highq = ScannableGroup('_fourc', (delta, th, chi, phi)) #I21DiffractometerStage('_fourc_highq', m5tth, sa,delta_offset=highq_OFFSET_ADDED_TO_DELTA_WHEN_READING) __main__.fourc_highq = DiffractometerScannableGroup('fourc_highq', _dc, _fourc_highq) __main__.hkl_highq = Hkl('hkl_highq', _fourc_highq, _dc) __main__.h_highq, __main__.k_highq, __main__.l_highq = hkl_highq.h, hkl_highq.k, hkl_highq.l #Update scannables: fourc_diode & hkl_diode' _fourc_diode = ScannableGroup('_fourc', (delta, th, chi, phi)) #I21DiffractometerStage('_fourc_diode', delta, sa) __main__.fourc_diode = DiffractometerScannableGroup('fourc_diode', _dc, _fourc_diode) __main__.hkl_diode = Hkl('hkl_diode', _fourc_diode, _dc) __main__.h_diode, __main__.k_diode, __main__.l_diode = hkl_diode.h, hkl_diode.k, hkl_diode.l
class TestSimulatedCrystalCounter(object): def setup_method(self): self.diff = MockScannable() self.wl = MockScannable() self.wl.pos = 1. self.eq = MockEquation() self.scc = SimulatedCrystalCounter('det', self.diff, Fourc(), self.wl, self.eq) def testInit(self): assert list(self.scc.getInputNames()) == ['det_count'] assert list(self.scc.getExtraNames()) == [] assert self.scc.chiMissmount == 0. assert self.scc.phiMissmount == 0. def testCalcUB(self): UB = matrix([[2 * pi, 0, 0], [0, 2 * pi, 0], [0, 0, 2 * pi]]) mneq_(self.scc.UB, UB) def testGetHkl(self): self.diff.pos = [60, 30, 0, 0] hkl = self.scc.getHkl() assert hkl == approx((1, 0, 0)) self.diff.pos = [60, 31, 0, 0] hkl = self.scc.getHkl() assert hkl == approx((0.999847695156391, 0.017452406437283574, 0)) def testGetPosition(self): self.diff.pos = [60, 30, 0, 0] self.scc.asynchronousMoveTo(2) count = self.scc.getPosition() assert self.eq.dHkl == approx((0, 0, 0)) assert count == 2 self.diff.pos = [60, 31, 0, 0] count = self.scc.getPosition() dHkl = (0.999847695156391 - 1, .017452406437283574, 0) assert self.eq.dHkl == approx(dHkl) assert count == 2 def test__repr__(self): self.diff.pos = [60, 30, 0, 0] print self.scc.__repr__()
_virtual_angles = ('theta', 'ttheta', 'qaz', 'alpha', 'naz', 'tau', 'psi', 'beta', 'betain', 'betaout') else: _virtual_angles = ('theta', 'ttheta', 'qaz', 'betain', 'betaout') hklverbose = Hkl('hklverbose', _scn_group, _dc, _virtual_angles) # Create wavelength scannable wl = Wavelength('wl', _energy_scannable, settings.energy_scannable_multiplier_to_get_KeV) if not GDA: wl.asynchronousMoveTo(1) # Angstrom _energy_scannable.level = 3 wl.level = 3 # Create simulated counter timer ct = SimulatedCrystalCounter('ct', _scn_group, settings.geometry, wl) ct.level = 10 # Create constraint scannables def _create_constraint_scannable(con_name, scn_name=None): if not scn_name: scn_name = con_name return DiffractionCalculatorParameter(scn_name, con_name, _dc.constraint_manager) # Detector constraints def isconstrainable(name): return not constraint_manager.is_constraint_fixed(name)
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
_virtual_angles = ('theta', 'qaz', 'alpha', 'naz', 'tau', 'psi', 'beta') hklverbose = Hkl('hklverbose', _scn_group, _dc, _virtual_angles) # Create wavelength scannable wl = Wavelength( 'wl', _energy_scannable, settings.energy_scannable_multiplier_to_get_KeV) if not GDA: wl.asynchronousMoveTo(1) # Angstrom _energy_scannable.level = 3 wl.level = 3 # Create simulated counter timer ct = SimulatedCrystalCounter('ct', _scn_group, settings.geometry, wl) ct.level = 10 # Create constraint scannables def _create_constraint_scannable(con_name, scn_name=None): if not scn_name: scn_name = con_name return DiffractionCalculatorParameter( scn_name, con_name, _dc.constraint_manager) # Detector constraints def isconstrainable(name): return not constraint_manager.is_constraint_fixed(name) if isconstrainable('delta'): delta_con = _create_constraint_scannable('delta', 'delta_con')