Example #1
0
 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__()
Example #3
0
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
Example #4
0
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
Example #5
0
    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)
Example #7
0
    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
Example #8
0
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__()
Example #9
0
    _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)
Example #10
0
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
Example #11
0
_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')