示例#1
0
    def _load_inst_parameters(self):
        """
            Loads an empty VESUVIO instrument and attaches the necessary
            parameters as attributes
        """
        isis = config.getFacility("ISIS")
        inst_name = "VESUVIO"
        inst_dir = config.getInstrumentDirectory()
        inst_file = os.path.join(inst_dir, inst_name + "_Definition.xml")
        __empty_vesuvio_ws = LoadEmptyInstrument(Filename=inst_file,
                                                 EnableLogging=_LOGGING_)
        empty_vesuvio = __empty_vesuvio_ws.getInstrument()

        def to_int_list(str_param):
            """Return the list of numbers described by the string range"""
            elements = str_param.split("-")
            return range(int(elements[0]),
                         int(elements[1]) + 1)  # range goes x_l,x_h-1

        # Attach parameters as attributes
        self._inst_prefix = isis.instrument(inst_name).shortName()
        parnames = empty_vesuvio.getParameterNames(False)
        for name in parnames:
            # Irritating parameter access doesn't let you query the type
            # so resort to trying
            try:
                parvalue = empty_vesuvio.getNumberParameter(name)
            except RuntimeError:
                parvalue = empty_vesuvio.getStringParameter(name)
            setattr(self, name, parvalue[0])

        self._mon_spectra = [int(self.monitor_spectrum)]
        self._mon_index = self._mon_spectra[0] - 1

        self._backward_spectra_list = to_int_list(
            self.backward_scatter_spectra)
        self._forward_spectra_list = to_int_list(self.forward_scatter_spectra)
        self._mon_scale = self.monitor_scale
        self._beta = self.double_diff_mixing
        self._tof_max = self.tof_max
        self._mon_tof_max = self.monitor_tof_max

        # Normalisation ranges
        def to_range_tuple(str_range):
            """Return a list of 2 floats giving the lower,upper range"""
            elements = str_range.split("-")
            return (float(elements[0]), float(elements[1]))

        self._back_mon_norm = to_range_tuple(self.backward_monitor_norm)
        self._back_period_sum1 = to_range_tuple(self.backward_period_sum1)
        self._back_period_sum2 = to_range_tuple(self.backward_period_sum2)
        self._back_foil_out_norm = to_range_tuple(self.backward_foil_out_norm)

        self._forw_mon_norm = to_range_tuple(self.forward_monitor_norm)
        self._forw_period_sum1 = to_range_tuple(self.forward_period_sum1)
        self._forw_period_sum2 = to_range_tuple(self.forward_period_sum2)
        self._forw_foil_out_norm = to_range_tuple(self.forward_foil_out_norm)

        DeleteWorkspace(__empty_vesuvio_ws, EnableLogging=_LOGGING_)
示例#2
0
    def _load_inst_parameters(self):
        """
            Loads an empty VESUVIO instrument and attaches the necessary 
            parameters as attributes 
        """
        isis = config.getFacility("ISIS")
        inst_name = "VESUVIO"
        inst_dir = config.getInstrumentDirectory()
        inst_file = os.path.join(inst_dir, inst_name + "_Definition.xml")
        __empty_vesuvio_ws = LoadEmptyInstrument(Filename=inst_file, EnableLogging=_LOGGING_)
        empty_vesuvio = __empty_vesuvio_ws.getInstrument()
        
        def to_int_list(str_param):
            """Return the list of numbers described by the string range"""
            elements = str_param.split("-")
            return range(int(elements[0]),int(elements[1]) + 1) # range goes x_l,x_h-1
        
        # Attach parameters as attributes
        self._inst_prefix = isis.instrument(inst_name).shortName()
        parnames = empty_vesuvio.getParameterNames(False)
        for name in parnames:
            # Irritating parameter access doesn't let you query the type
            # so resort to trying
            try:
                parvalue = empty_vesuvio.getNumberParameter(name)
            except RuntimeError:
                parvalue = empty_vesuvio.getStringParameter(name)
            setattr(self, name, parvalue[0])

        self._mon_spectra = [int(self.monitor_spectrum)]
        self._mon_index = self._mon_spectra[0] - 1

        self._backward_spectra_list = to_int_list(self.backward_scatter_spectra)
        self._forward_spectra_list = to_int_list(self.forward_scatter_spectra)
        self._tau = self.dead_time_fraction
        self._mon_scale = self.monitor_scale
        self._beta =  self.double_diff_mixing
        self._tof_max = self.tof_max
        self._mon_tof_max = self.monitor_tof_max
        
        # Normalisation ranges
        def to_range_tuple(str_range):
            """Return a list of 2 floats giving the lower,upper range"""
            elements = str_range.split("-")
            return (float(elements[0]),float(elements[1]))
            
        self._back_mon_norm = to_range_tuple(self.backward_monitor_norm)
        self._back_period_sum1 = to_range_tuple(self.backward_period_sum1)
        self._back_period_sum2 = to_range_tuple(self.backward_period_sum2)
        self._back_foil_out_norm = to_range_tuple(self.backward_foil_out_norm)

        self._forw_mon_norm = to_range_tuple(self.forward_monitor_norm)
        self._forw_period_sum1 = to_range_tuple(self.forward_period_sum1)
        self._forw_period_sum2 = to_range_tuple(self.forward_period_sum2)
        self._forw_foil_out_norm = to_range_tuple(self.forward_foil_out_norm)

        DeleteWorkspace(__empty_vesuvio_ws,EnableLogging=_LOGGING_)
示例#3
0
 def _load_param_file(self, inst_name):
     InstrumentParameters.instrument_name = inst_name
     if IS_IN_MANTIDPLOT:
         idf_loc = config.getInstrumentDirectory()
         idf_pattern = os.path.join(idf_loc, "%s_Definition*.xml") % inst_name
         import glob
         idf_files = glob.glob(idf_pattern)
         emptyInst = LoadEmptyInstrument(Filename=str(idf_files[0]))
         InstrumentParameters._instrument = emptyInst.getInstrument()
         AnalysisDataService.remove(str(emptyInst)) # Don't need to keep workspace
示例#4
0
 def _load_param_file(self, inst_name):
     InstrumentParameters.instrument_name = inst_name
     if IS_IN_MANTIDPLOT:
         idf_loc = config.getInstrumentDirectory()
         idf_pattern = os.path.join(idf_loc, "%s_Definition*.xml") % inst_name
         import glob
         idf_files = glob.glob(idf_pattern)
         emptyInst = LoadEmptyInstrument(Filename=str(idf_files[0]))
         InstrumentParameters._instrument = emptyInst.getInstrument()
         AnalysisDataService.remove(str(emptyInst)) # Don't need to keep workspace
示例#5
0
    def test_get_set_matrix_workspace(self):
        ws = LoadEmptyInstrument(InstrumentName='ENGIN-X', OutputWorkspace='ws')
        LoadParameterFile(Workspace=ws, Filename='ENGIN-X_Parameters.xml')
        axis = ws.getAxis(0)
        unit = axis.getUnit()
        axis.setUnit("TOF")

        func = FunctionFactory.Instance().createPeakFunction("BackToBackExponential")
        func.setParameter(3, 24000)  # set centre
        func.setMatrixWorkspace(ws, 800, 0.0, 0.0)  # calculate A,B,S
        self.assertTrue(func.isExplicitlySet(1))
示例#6
0
 def setUp(self) -> None:
     # Neutron counts along a tube
     counts = [50, 122, 118, 197, 414, 545, 1026, 1767, 3242, 7132, 16232, 34663, 52842, 59767, 58638, 55250, 47723,
               47400, 54642, 56830, 57664, 57563, 57398, 57438, 57370, 57386, 57447, 56951, 57258, 56195, 52775,
               46106, 48802, 54698, 57072, 57876, 57754, 57712, 57800, 57837, 57606, 57398, 57038, 56504, 54408,
               49406, 44668, 50911, 55364, 55906, 56175, 56612, 56375, 56179, 56265, 56329, 56497, 56131, 55034,
               52618, 46515, 44466, 51293, 54234, 54961, 55219, 54601, 54359, 54866, 54839, 54474, 54031, 54064,
               53431, 50619, 44013, 45435, 52264, 54087, 55002, 54589, 54568, 53516, 53285, 52656, 52676, 52420,
               52375, 51837, 47664, 41643, 45292, 51215, 52851, 53284, 53421, 52999, 52985, 52596, 52799, 52658,
               51894, 51504, 50154, 44435, 39820, 45640, 49871, 50920, 51190, 51091, 51448, 50937, 50927, 50773,
               51173, 50819, 50110, 48138, 42389, 39823, 46671, 50037, 50013, 50840, 50400, 50138, 49500, 50616,
               49890, 49853, 49548, 48731, 45211, 39185, 39270, 45409, 47628, 48348, 48652, 48025, 48518, 48915,
               48351, 48486, 48391, 47793, 47079, 43590, 37528, 40016, 45604, 47259, 47710, 47252, 47687, 47145,
               47453, 47409, 47294, 46735, 46170, 45028, 40783, 35924, 40234, 44613, 45660, 45921, 45125, 45544,
               45482, 45261, 45326, 45547, 44914, 44966, 43711, 39302, 35101, 39600, 44185, 45054, 44538, 44443,
               44617, 44509, 44589, 44806, 45078, 44265, 44053, 42055, 36702, 35192, 40304, 42712, 42910, 42992,
               43593, 44157, 43675, 43442, 43348, 43668, 42447, 42193, 39349, 33887, 34026, 38630, 40354, 40798,
               40866, 40592, 40593, 40645, 40507, 40316, 40256, 40068, 39481, 37928, 33034, 31521, 36298, 38938,
               39451, 39544, 39479, 39624, 39471, 39300, 39197, 38777, 39288, 39163, 37350, 33507, 31309, 36124,
               38921, 30633, 14932, 5370, 2069, 955, 545, 329, 216, 157, 82, 49, 54, 25, 10]
     # Calibrated Y-coordinates
     y = [-0.342, -0.338, -0.335, -0.331, -0.328, -0.324, -0.320, -0.317, -0.313, -0.310, -0.306, -0.303, -0.299,
          -0.296, -0.292, -0.289, -0.285, -0.282, -0.278, -0.275, -0.271, -0.268, -0.264, -0.261, -0.257, -0.254,
          -0.250, -0.247, -0.243, -0.240, -0.236, -0.232, -0.229, -0.225, -0.222, -0.218, -0.215, -0.211, -0.208,
          -0.204, -0.201, -0.197, -0.194, -0.190, -0.187, -0.183, -0.180, -0.176, -0.173, -0.169, -0.166, -0.162,
          -0.159, -0.155, -0.152, -0.148, -0.144, -0.141, -0.137, -0.134, -0.130, -0.127, -0.123, -0.120, -0.116,
          -0.113, -0.109, -0.106, -0.102, -0.099, -0.095, -0.092, -0.088, -0.085, -0.081, -0.078, -0.074, -0.071,
          -0.067, -0.064, -0.060, -0.056, -0.053, -0.049, -0.046, -0.042, -0.039, -0.035, -0.032, -0.028, -0.025,
          -0.021, -0.018, -0.014, -0.011, -0.007, -0.004, -0.000,  0.003,  0.007,  0.010,  0.014,  0.017,  0.021,
          0.024,  0.028,  0.032,  0.035,  0.039,  0.042,  0.046,  0.049,  0.053,  0.056,  0.060,  0.063,  0.067,
          0.070,  0.074,  0.077,  0.081,  0.084,  0.088,  0.091,  0.095,  0.098,  0.102,  0.105,  0.109,  0.112,
          0.116,  0.120,  0.123,  0.127,  0.130,  0.134,  0.137,  0.141,  0.144,  0.148,  0.151,  0.155,  0.158,
          0.162,  0.165,  0.169,  0.172,  0.176,  0.179,  0.183,  0.186,  0.190,  0.193,  0.197,  0.200,  0.204,
          0.208,  0.211,  0.215,  0.218,  0.222,  0.225,  0.229,  0.232,  0.236,  0.239,  0.243,  0.246,  0.250,
          0.253,  0.257,  0.260,  0.264,  0.267,  0.271,  0.274,  0.278,  0.281,  0.285,  0.288,  0.292,  0.296,
          0.299,  0.303,  0.306,  0.310,  0.313,  0.317,  0.320,  0.324,  0.327,  0.331,  0.334,  0.338,  0.341,
          0.345,  0.348,  0.352,  0.355,  0.359,  0.362,  0.366,  0.369,  0.373,  0.376,  0.380,  0.384,  0.387,
          0.391,  0.394,  0.398,  0.401,  0.405,  0.408,  0.412,  0.415,  0.419,  0.422,  0.426,  0.429,  0.433,
          0.436,  0.440,  0.443,  0.447,  0.450,  0.454,  0.457,  0.461,  0.464,  0.468,  0.472,  0.475,  0.479,
          0.482,  0.486,  0.489,  0.493,  0.496,  0.500,  0.503,  0.507,  0.510,  0.514,  0.517,  0.521,  0.524,
          0.528,  0.531,  0.535,  0.538,  0.542,  0.545,  0.549,  0.552,  0.556]
     # Create a workspace with an uncalibrated tube bank42/sixteenpack/tube8
     workspace = LoadEmptyInstrument(InstrumentName='CORELLI', MakeEventWorkspace=False,
                                     OutputWorkspace='uncalibrated')
     # the workspace index for the first pixel in bank87/sixteenpack/tube12 is 355075
     for pixel_index in range(256):
         workspace.dataY(355075 + pixel_index)[:] = counts[pixel_index]
     self.workspace = 'uncalibrated'
     self.table = 'calibTable'
     self.calibrated_y = y
    def runTest(self):
        # apply the calibration to a reference CORELLI instrument
        self.ws_reference = "ws_ref"
        self.ws_calbrated = "ws_cal"
        LoadEmptyInstrument(Filename="CORELLI_Definition.xml",
                            OutputWorkspace=self.ws_reference)
        ConvertToEventWorkspace(InputWorkspace=self.ws_reference,
                                OutputWorkspace=self.ws_calbrated)
        self.generate_calitab()
        CorelliCalibrationApply(Workspace=self.ws_calbrated,
                                CalibrationTable=self.cali_table_name)
        # ensure that the calibration application take place
        _ws_ref = mtd[self.ws_reference]
        _ws_cal = mtd[self.ws_calbrated]
        rst, _ = CompareWorkspaces(_ws_ref, _ws_cal)
        if rst is True:
            raise ValueError("The Calibration is not applied to workspace")

        # get the target ws
        self.get_target_instrument()
        _ws_tgt = mtd[self.ws_target]

        # check if the calibrated workspace matches the target
        rst, msg = CompareWorkspaces(_ws_tgt, _ws_cal)
        # NOTE:
        #  Currently comparing the two workspace will yield False even if the implementation
        #  is exactly the same as the C++ counter parts.
        #  Given that this is just a place holder for more comprehensive systemtest onece
        #  the upstream calibration algorithm is complete, we are skipping the checking here.
        print(msg)
示例#8
0
def _table_to_workspace(
        input_workspace: Union[str, TableWorkspace],
        output_workspace: Optional[str] = None) -> MaskWorkspace:
    r"""
    @brief Convert a CORELLI calibration mask table to a MaskWorkspace

    :param input_workspace : the table containing the detector ID's for the masked detectors
    :param output_workspace : name of the output MaskWorkspace

    :return: handle to the MaskWorkspace
    """
    table_handle = mtd[str(input_workspace)]
    detectors_masked = table_handle.column(0)  # list of masked detectors
    if output_workspace is None:
        output_workspace = str(input_workspace)
    LoadEmptyInstrument(InstrumentName='CORELLI',
                        OutputWorkspace=output_workspace)
    ClearMaskFlag(Workspace=output_workspace)  # for good measure
    MaskDetectors(
        Workspace=output_workspace,
        DetectorList=detectors_masked)  # output_workspace is a Workspace2D
    # output_workspace is converted to a MaskWorkspace, where the Y-values of the spectra are now either 0 or 1
    ExtractMask(InputWorkspace=output_workspace,
                OutputWorkspace=output_workspace)
    return mtd[output_workspace]
示例#9
0
    def _create_peaks_workspace(self):
        """Create a dummy peaks workspace"""
        path = FileFinder.getFullPath(
            "IDFs_for_UNIT_TESTING/MINITOPAZ_Definition.xml")
        inst = LoadEmptyInstrument(Filename=path)
        ws = CreatePeaksWorkspace(inst, 0)
        DeleteWorkspace(inst)
        SetUB(ws, 1, 1, 1, 90, 90, 90)

        # Add a bunch of random peaks that happen to fall on the
        # detetor bank defined in the IDF
        center_q = np.array([-5.1302, 2.5651, 3.71809])
        qs = []
        for i in np.arange(0, 1, 0.1):
            for j in np.arange(-0.5, 0, 0.1):
                q = center_q.copy()
                q[1] += j
                q[2] += i
                qs.append(q)

        # Add the peaks to the PeaksWorkspace with dummy values for intensity,
        # Sigma, and HKL
        for q in qs:
            peak = ws.createPeak(q)
            peak.setIntensity(100)
            peak.setSigmaIntensity(10)
            peak.setHKL(1, 1, 1)
            ws.addPeak(peak)

        return ws
示例#10
0
def _get_instrument_structure(ws):
    """Returns the number of detectors and the number of detectors per tube in the currently processed
    instrument."""
    instrument = ws.getInstrument().getName()
    if instrument in ['IN4', 'IN6']:
        self.log.warning(
            "Grouping pattern cannot be provided for IN4 and IN6.")
        return ""
    tmp_inst = '{}_tmp'.format(instrument)
    LoadEmptyInstrument(InstrumentName=instrument, OutputWorkspace=tmp_inst)
    tmp_mon_inst = 'mon_{}'.format(tmp_inst)
    ExtractMonitors(InputWorkspace=tmp_inst,
                    DetectorWorkspace=tmp_inst,
                    MonitorWorkspace=tmp_mon_inst)
    n_monitors = mtd[tmp_mon_inst].getNumberHistograms()
    n_tubes = 0
    for comp in mtd[tmp_inst].componentInfo():
        if len(comp.detectorsInSubtree) > 1 and comp.hasParent:
            n_tubes += 1
    n_tubes -= n_monitors
    if instrument == 'IN5':  # there is an extra bank that contains all of the tubes
        n_tubes -= 1
    n_pixels = mtd[tmp_inst].getNumberHistograms()
    n_pixels_per_tube = int(n_pixels / n_tubes)
    DeleteWorkspace(Workspace=tmp_inst)
    DeleteWorkspace(Workspace=tmp_mon_inst)
    return n_pixels, n_pixels_per_tube
示例#11
0
def test_duplicate_monitor_names():
    from mantid.simpleapi import LoadEmptyInstrument
    ws = LoadEmptyInstrument(
        InstrumentName='POLARIS',
        StoreInADS=False)  # Has many monitors named 'monitor'
    da = scn.mantid.from_mantid(ws)
    assert da.attrs['monitor_1'].value.attrs['spectrum'].value == 1
    assert da.attrs['monitor_13'].value.attrs['spectrum'].value == 13
    assert da.attrs['monitor_14'].value.attrs['spectrum'].value == 14
示例#12
0
def _load_indirect_instrument(instr, parameters):
    from mantid.simpleapi import LoadEmptyInstrument, \
        LoadParameterFile, AddSampleLog, config
    # Create a workspace from an indirect instrument
    out = LoadEmptyInstrument(InstrumentName=instr)
    if instr in parameters:
        LoadParameterFile(out,
                          Filename=os.path.join(
                              config.getInstrumentDirectory(),
                              parameters[instr]))
    if not out.run().hasProperty('EMode'):
        # EMode would usually get attached via data loading
        # We skip that so have to apply manually
        AddSampleLog(out,
                     LogName='EMode',
                     LogText='Indirect',
                     LogType='String')
    return out
示例#13
0
def load_component_info_to_2d(geometry_file, sizes, advanced_geometry=False):
    """Load geometry information from a mantid Instrument Definition File
        or a NeXuS file containing instrument geometry. and reshape into 2D
        physical dimensions.

        This function requires mantid-framework to be installed

        :param geometry_file: IDF or NeXus file
        :param sizes: Dict of dim to size for output
        :return Dataset containing items for positions,
            rotations and shapes
        :raises ImportError if mantid cannot be imported
        :raises ValueError if sizes argument invalid
        """
    from mantid.simpleapi import LoadEmptyInstrument
    ws = LoadEmptyInstrument(Filename=geometry_file, StoreInADS=False)
    source_pos, sample_pos = scn.mantid.make_component_info(ws)
    geometry = sc.Dataset()
    geometry["source_position"] = source_pos
    geometry["sample_position"] = sample_pos
    pos, rot, shp = scn.mantid.get_detector_properties(
        ws,
        source_pos,
        sample_pos,
        spectrum_dim='spectrum',
        advanced_geometry=advanced_geometry)
    pos_shape = pos.shape[0]
    reshape_volume = reduce(operator.mul, sizes.values(), 1)
    if not pos_shape == reshape_volume:
        raise ValueError(
            f'file contains {pos_shape} spectra, but you are attempting\
            to reshape to an output with volume\
            {reshape_volume} via sizes argument')
    fold_args = {
        'dim': 'spectrum',
        'dims': sizes.keys(),
        'shape': sizes.values()
    }
    pos2d = sc.fold(pos, **fold_args)
    geometry["position"] = pos2d
    if rot is not None:
        rot2d = sc.fold(rot, **fold_args)
        geometry["rotation"] = rot2d
    if shp is not None:
        shp2d = sc.fold(shp, **fold_args)
        geometry["shape"] = shp2d
    # Could be upgraded, but logic complex for mapping to fields of vector
    # We therefore limit the element coord generation to x, y, z only
    if set(sizes.keys()).issubset({'x', 'y', 'z'}):
        for u, v in zip(sizes.keys(), reversed(list(sizes.keys()))):
            geometry[u] = getattr(pos2d.fields, u)[v, 0]
    return geometry
    def runTest(self):
        ws = LoadEmptyInstrument(InstrumentName='WISH')
        UB = np.array([[-0.00601763, 0.07397297, 0.05865706],
                       [0.05373321, 0.050198, -0.05651455],
                       [-0.07822144, 0.0295911, -0.04489172]])

        SetUB(ws, UB=UB)

        self._peaks = PredictPeaks(ws,
                                   WavelengthMin=0.1,
                                   WavelengthMax=100,
                                   OutputWorkspace='peaks')
        # We specifically want to check peak -5 -1 -7 exists, so filter for it
        self._filtered = FilterPeaks(self._peaks,
                                     "h^2+k^2+l^2",
                                     75,
                                     '=',
                                     OutputWorkspace='filtered')

        SaveIsawPeaks(self._peaks, Filename='WISHSXReductionPeaksTest.peaks')
示例#15
0
 def setUp(self):
     # load empty instrument so can create a peak table
     self.ws = LoadEmptyInstrument(InstrumentName='SXD',
                                   OutputWorkspace='sxd')
     ub = np.array([[-0.00601763, 0.07397297, 0.05865706],
                    [0.05373321, 0.050198, -0.05651455],
                    [-0.07822144, 0.0295911, -0.04489172]])
     SetUB(self.ws, UB=ub)
     PredictPeaks(self.ws,
                  WavelengthMin=1,
                  WavelengthMax=1.1,
                  MinDSpacing=1,
                  MaxDSPacing=1.1,
                  OutputWorkspace='test')  # 8 peaks
     PredictSatellitePeaks(Peaks='test',
                           SatellitePeaks='test_sat',
                           ModVector1='0,0,0.33',
                           MaxOrder=1)
     self.peaks = CombinePeaksWorkspaces(LHSWorkspace='test_sat',
                                         RHSWorkspace='test',
                                         OutputWorkspace='test')
示例#16
0
    def runTest(self):
        prefix = 'mU6g7vP92_'  # pseudo-random string to prefix workspace names
        LoadAscii(Filename='SNAP_51984_peakcenters_tof.dat',
                  Separator='Tab',
                  Unit='Dimensionless', OutputWorkspace=prefix + 'peak_centers')
        LoadEmptyInstrument(InstrumentName='SNAP', OutputWorkspace=prefix + 'snap')

        with capture_logs(level='debug') as logs:
            AlignComponents(PeakCentersTofTable=prefix + 'peak_centers',
                            PeakPositions='1.3143, 1.3854,1.6967, 1.8587, 2.0781',
                            AdjustmentsTable=prefix + 'adjustments',
                            DisplacementsTable=prefix + 'displacements',
                            InputWorkspace=prefix + 'snap',
                            OutputWorkspace=prefix + 'snap_modified',
                            FitSourcePosition=False, FitSamplePosition=False,
                            ComponentList='Column1',
                            XPosition=False, YPosition=False, ZPosition=True,
                            AlphaRotation=False, BetaRotation=False, GammaRotation=False)
            assert 'First and last detectorID for Column1 are 0, 196607' in logs.getvalue()

        # Clean up workspaces
        temporary = ['peak_centers', 'snap', 'adjustments', 'displacements', 'snap_modified']
        DeleteWorkspaces([prefix + suffix for suffix in temporary])
 def runTest(self):
     # Load Empty Instrument
     ws = LoadEmptyInstrument(InstrumentName='WISH', OutputWorkspace='WISH')
     axis = ws.getAxis(0)
     axis.setUnit("TOF")  # need this to add peak to table
     # CreatePeaksWorkspace with peaks in specific detectors
     peaks = CreatePeaksWorkspace(InstrumentWorkspace=ws,
                                  NumberOfPeaks=0,
                                  OutputWorkspace='peaks')
     AddPeak(PeaksWorkspace=peaks,
             RunWorkspace=ws,
             TOF=20000,
             DetectorID=1707204,
             Height=521,
             BinCount=0)  # pixel in first tube in panel 1
     AddPeak(PeaksWorkspace=peaks,
             RunWorkspace=ws,
             TOF=20000,
             DetectorID=1400510,
             Height=1,
             BinCount=0)  # pixel at top of a central tube in panel 1
     AddPeak(PeaksWorkspace=peaks,
             RunWorkspace=ws,
             TOF=20000,
             DetectorID=1408202,
             Height=598,
             BinCount=0)  # pixel in middle of bank 1 (not near edge)
     AddPeak(PeaksWorkspace=peaks,
             RunWorkspace=ws,
             TOF=20000,
             DetectorID=1100173,
             Height=640,
             BinCount=0)  # pixel in last tube of panel 1 (next to panel 2)
     # create dummy MD workspace for integration (don't need data as checking peak shape)
     MD = CreateMDWorkspace(Dimensions='3',
                            Extents='-1,1,-1,1,-1,1',
                            Names='Q_lab_x,Q_lab_y,Q_lab_z',
                            Units='U,U,U',
                            Frames='QLab,QLab,QLab',
                            SplitInto='2',
                            SplitThreshold='50')
     # Integrate peaks masking all pixels at tube end (built into IntegratePeaksMD)
     self._peaks_pixels = IntegratePeaksMD(InputWorkspace=MD,
                                           PeakRadius='0.02',
                                           PeaksWorkspace=peaks,
                                           IntegrateIfOnEdge=False,
                                           OutputWorkspace='peaks_pixels',
                                           MaskEdgeTubes=False)
     # Apply masking to specific tubes next to beam in/out (subset of all edge tubes) and integrate again
     MaskBTP(Workspace='peaks', Bank='5-6', Tube='152')
     MaskBTP(Workspace='peaks', Bank='1,10', Tube='1')
     self._peaks_pixels_beamTubes = IntegratePeaksMD(
         InputWorkspace='MD',
         PeakRadius='0.02',
         PeaksWorkspace=peaks,
         IntegrateIfOnEdge=False,
         OutputWorkspace='peaks_pixels_beamTubes',
         MaskEdgeTubes=False)
     # Integrate masking all edge tubes
     self._peaks_pixels_edgeTubes = IntegratePeaksMD(
         InputWorkspace='MD',
         PeakRadius='0.02',
         PeaksWorkspace='peaks',
         IntegrateIfOnEdge=False,
         OutputWorkspace='peaks_pixels_edgeTubes',
         MaskEdgeTubes=True)
示例#18
0
from mantid.simpleapi import LoadDiffCal, mtd, LoadEmptyInstrument, CalculateDIFC, MaskBTP, CloneWorkspace, SaveDiffCal, ApplyCalibration
import matplotlib.pyplot as plt
import tube
import numpy as np
import numpy.ma as ma

tube.readCalibrationFile(
    'CalibTable', '/SNS/users/rwp/corelli/tube_calibration/CalibTableNew.txt')

corelli = LoadEmptyInstrument(InstrumentName='CORELLI')
corelli = CalculateDIFC(corelli)
difc0 = corelli.extractY().flatten()
ApplyCalibration('corelli', 'CalibTable')
corelli = CalculateDIFC(corelli)
difc = corelli.extractY().flatten()

plt.plot(difc / difc0)
plt.show()

LoadDiffCal(
    Filename='../cal_Si_C60/cal_Si2_47327-47334_TubeCal_sum16_mask_lt_2.cal',
    InstrumentName='CORELLI',
    WorkspaceName='si')
MaskBTP(Workspace='si_mask', Pixel="1-16,241-256")

LoadDiffCal(
    Filename='../cal_Si_C60/cal_C60_2_47367-47382_TubeCal_sum16_mask_lt_2.h5',
    InstrumentName='CORELLI',
    WorkspaceName='c60')
MaskBTP(Workspace='c60_mask', Pixel="1-16,241-256")
示例#19
0
#!/usr/bin/python2
from __future__ import print_function
from mantid.simpleapi import LoadEmptyInstrument, MoveInstrumentComponent, mtd
import numpy as np

LoadEmptyInstrument(Filename='/SNS/users/rwp/CORELLI_Definition_91.07cm.xml',
                    OutputWorkspace='ws')
ws = mtd['ws']
#[x,_,z] = mtd['ws'].getInstrument().getComponentByName('CORELLI/bank46/sixteenpack/tube3/pixel128').getPos()
#[_,y,_] = mtd['ws'].getInstrument().getComponentByName('CORELLI/bank46/sixteenpack/tube3').getPos()
#MoveInstrumentComponent('ws', ComponentName='CORELLI/bank46/sixteenpack/tube3/pixel128', X=x, Y=y, Z=z, RelativePosition=False)


def pixel(A, E1, E2, x):
    return 255 * A * (x - E1) / (E2 - E1 + (A - 1) * (x - E1))


with open('curvefitmain.txt', "r") as f:
    lines = f.readlines()

lengths = []
for line in lines:
    if not 'channel' in line:
        continue
    _, channel, _, roc, _, A, _, E1, _, E2 = line.split()
    channel = float(channel)
    roc = float(roc)
    A = float(A)
    E1 = float(E1)
    E2 = float(E2)
    lengths.append(E2 - E1)
class FindGlobalBMatrixTest(unittest.TestCase):
    def setUp(self):
        # load empty instrument so can create a peak table
        self.ws = LoadEmptyInstrument(InstrumentName='SXD',
                                      OutputWorkspace='empty_SXD')
        axis = self.ws.getAxis(0)
        axis.setUnit("TOF")

    def tearDown(self):
        AnalysisDataService.clear()

    def test_finds_average_lattice_parameter(self):
        # create two peak tables with UB corresponding to different lattice constant, a
        peaks1 = CreatePeaksWorkspace(InstrumentWorkspace=self.ws,
                                      NumberOfPeaks=0,
                                      OutputWorkspace="SXD_peaks1")
        UB = np.diag([1.0 / 3.9, 0.25, 0.1])  # alatt = [3.9, 4, 10]
        SetUB(peaks1, UB=UB)
        peaks2 = CreatePeaksWorkspace(InstrumentWorkspace=self.ws,
                                      NumberOfPeaks=0,
                                      OutputWorkspace="SXD_peaks2")
        UB = np.diag([1.0 / 4.1, 0.25, 0.1])  # alatt = [4.1, 4, 10]
        SetUB(peaks2, UB=UB)
        # Add some peaks
        add_peaksHKL([peaks1, peaks2], range(0, 3), range(0, 3), 4)

        FindGlobalBMatrix(PeakWorkspaces=[peaks1, peaks2],
                          a=4.1,
                          b=4.2,
                          c=10,
                          alpha=88,
                          beta=88,
                          gamma=89,
                          Tolerance=0.15)

        # check lattice  - should have average a=4.0
        self.assert_lattice([peaks1, peaks2],
                            4.0,
                            4.0,
                            10.0,
                            90.0,
                            90.0,
                            90.0,
                            delta_latt=5e-2,
                            delta_angle=2.5e-1)
        self.assert_matrix([peaks1],
                           getBMatrix(peaks2),
                           getBMatrix,
                           delta=1e-10)  # should have same B matrix
        self.assert_matrix([peaks1, peaks2], np.eye(3), getUMatrix, delta=5e-2)

    def test_handles_inaccurate_goniometer(self):
        peaks1 = CreatePeaksWorkspace(InstrumentWorkspace=self.ws,
                                      NumberOfPeaks=0,
                                      OutputWorkspace="SXD_peaks3")
        peaks2 = CloneWorkspace(InputWorkspace=peaks1,
                                OutputWorkspace="SXD_peaks4")
        # set different gonio on each run
        rot = 5
        SetGoniometer(Workspace=peaks1, Axis0=f'{-rot},0,1,0,1')
        SetGoniometer(Workspace=peaks2, Axis0=f'{rot},0,1,0,1')
        # Add peaks at QLab corresponding to slightly different gonio rotations
        UB = np.diag([0.25, 0.25, 0.1])  # alatt = [4,4,10]
        for h in range(0, 3):
            for k in range(0, 3):
                hkl = np.array([h, k, 4])
                qlab = 2 * np.pi * np.matmul(
                    np.matmul(getR(-(rot + 1), [0, 1, 0]), UB), hkl)
                pk = peaks1.createPeak(qlab)
                peaks1.addPeak(pk)
                qlab = 2 * np.pi * np.matmul(
                    np.matmul(getR(rot + 1, [0, 1, 0]), UB), hkl)
                pk = peaks2.createPeak(qlab)
                peaks2.addPeak(pk)

        FindGlobalBMatrix(PeakWorkspaces=[peaks1, peaks2],
                          a=4.15,
                          b=3.95,
                          c=10,
                          alpha=88,
                          beta=88,
                          gamma=89,
                          Tolerance=0.15)

        # check lattice - shouldn't be effected by error in goniometer
        self.assert_lattice([peaks1, peaks2],
                            4.0,
                            4.0,
                            10.0,
                            90.0,
                            90.0,
                            90.0,
                            delta_latt=2e-2,
                            delta_angle=2.5e-1)
        self.assert_matrix([peaks1],
                           getBMatrix(peaks2),
                           getBMatrix,
                           delta=1e-10)  # should have same B matrix
        self.assert_matrix([peaks1, peaks2], np.eye(3), getUMatrix, delta=5e-2)

    def test_requires_more_than_one_peak_workspace(self):
        peaks1 = CreatePeaksWorkspace(InstrumentWorkspace=self.ws,
                                      NumberOfPeaks=0,
                                      OutputWorkspace="SXD_peaks4")
        UB = np.diag([0.25, 0.25, 0.1])
        SetUB(peaks1, UB=UB)
        # Add some peaks
        add_peaksHKL([peaks1], range(0, 3), range(0, 3), 4)

        alg = create_algorithm('FindGlobalBMatrix',
                               PeakWorkspaces=[peaks1],
                               a=4.1,
                               b=4.2,
                               c=10,
                               alpha=88,
                               beta=88,
                               gamma=89,
                               Tolerance=0.15)

        with self.assertRaises(RuntimeError):
            alg.execute()

    def test_peak_workspaces_need_at_least_six_peaks_each(self):
        peaks1 = CreatePeaksWorkspace(InstrumentWorkspace=self.ws,
                                      NumberOfPeaks=0,
                                      OutputWorkspace="SXD_peaks5")
        UB = np.diag([0.25, 0.25, 0.1])
        SetUB(peaks1, UB=UB)
        # Add 5 peaks
        add_peaksHKL([peaks1], range(0, 5), [0], 4)
        peaks2 = CloneWorkspace(InputWorkspace=peaks1,
                                OutputWorkspace="SXD_peaks6")

        alg = create_algorithm('FindGlobalBMatrix',
                               PeakWorkspaces=[peaks1, peaks2],
                               a=4.1,
                               b=4.2,
                               c=10,
                               alpha=88,
                               beta=88,
                               gamma=89,
                               Tolerance=0.15)

        with self.assertRaises(RuntimeError):
            alg.execute()

    def test_performs_correct_transform_to_ensure_consistent_indexing(self):
        # create peaks tables
        peaks1 = CreatePeaksWorkspace(InstrumentWorkspace=self.ws,
                                      NumberOfPeaks=0,
                                      OutputWorkspace="SXD_peaks7")
        UB = np.diag([0.2, 0.25, 0.1])
        SetUB(peaks1, UB=UB)
        # Add some peaks
        add_peaksHKL([peaks1], range(0, 3), range(0, 3), 4)
        # Clone ws and transform
        peaks2 = CloneWorkspace(InputWorkspace=peaks1,
                                OutputWorkspace="SXD_peaks8")
        peaks2.removePeak(
            0)  # peaks1 will have most peaks indexed so will used as reference
        transform = np.array([[0, 1, 0], [1, 0, 0], [0, 0, -1]])
        TransformHKL(PeaksWorkspace=peaks2,
                     HKLTransform=transform,
                     FindError=False)

        FindGlobalBMatrix(PeakWorkspaces=[peaks1, peaks2],
                          a=4.15,
                          b=3.95,
                          c=10,
                          alpha=88,
                          beta=88,
                          gamma=89,
                          Tolerance=0.15)

        # check lattice - shouldn't be effected by error in goniometer
        self.assert_lattice([peaks1, peaks2],
                            5.0,
                            4.0,
                            10.0,
                            90.0,
                            90.0,
                            90.0,
                            delta_latt=5e-2,
                            delta_angle=2.5e-1)
        self.assert_matrix([peaks1],
                           getBMatrix(peaks2),
                           getBMatrix,
                           delta=1e-10)  # should have same B matrix
        self.assert_matrix([peaks1, peaks2], np.eye(3), getUMatrix, delta=5e-2)

    def assert_lattice(self,
                       ws_list,
                       a,
                       b,
                       c,
                       alpha,
                       beta,
                       gamma,
                       delta_latt=2e-2,
                       delta_angle=2.5e-1):
        for ws in ws_list:
            cell = ws.sample().getOrientedLattice()
            self.assertAlmostEqual(cell.a(), a, delta=delta_latt)
            self.assertAlmostEqual(cell.b(), b, delta=delta_latt)
            self.assertAlmostEqual(cell.c(), c, delta=delta_latt)
            self.assertAlmostEqual(cell.alpha(), alpha, delta=delta_angle)
            self.assertAlmostEqual(cell.beta(), beta, delta=delta_angle)
            self.assertAlmostEqual(cell.gamma(), gamma, delta=delta_angle)

    def assert_matrix(self, ws_list, ref_mat, extract_mat_func, delta=5e-2):
        for ws in ws_list:
            mat = extract_mat_func(ws)
            for ii in range(0, 3):
                for jj in range(0, 3):
                    self.assertAlmostEqual(mat[ii, jj],
                                           ref_mat[ii, jj],
                                           delta=delta)
示例#21
0
from mantid.simpleapi import LoadEmptyInstrument
import subprocess
import sys
import numpy as np

output = sys.argv[1]

corelli = LoadEmptyInstrument(InstrumentName='CORELLI')
inst = corelli.getInstrument()

def make_fityk_cmd(run, bank, tube):
    fityk_cmd = """@0 < 'COR_{0}_{1}_{2}.txt'
@0: A = a and not (-1 < x and x < 25.5)
@0: A = a and not (229.5 < x and x < 256)
$a = ~0.0
$b = ~282.0
$c = ~128.0
F += Lorentzian(height={3}, center=0.396*0.396*$a-0.396*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.3432*0.3432*$a-0.3432*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.2904*0.2904*$a-0.2904*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.2376*0.2376*$a-0.2376*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.1848*0.1848*$a-0.1848*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.132*0.132*$a-0.132*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.0792*0.0792*$a-0.0792*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.0264*0.0264*$a-0.0264*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.0264*0.0264*$a+0.0264*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.0792*0.0792*$a+0.0792*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.132*0.132*$a+0.132*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.1848*0.1848*$a+0.1848*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.2376*0.2376*$a+0.2376*$b+$c, hwhm=~1.28083)
F += Lorentzian(height={3}, center=0.2904*0.2904*$a+0.2904*$b+$c, hwhm=~1.28083)
 def get_target_instrument(self):
     self.ws_target = "ws_target"
     LoadEmptyInstrument(Filename="CORELLI_Definition.xml",
                         OutputWorkspace=self.ws_target)
     ConvertToEventWorkspace(InputWorkspace=self.ws_target,
                             OutputWorkspace=self.ws_target)
     # explicitly translate component TO designated location
     MoveInstrumentComponent(
         Workspace=self.ws_target,
         ComponentName="moderator",
         X=0,
         Y=0,
         Z=-19.9997,
         RelativePosition=False,
     )
     MoveInstrumentComponent(
         Workspace=self.ws_target,
         ComponentName="sample-position",
         X=0,
         Y=0,
         Z=0,
         RelativePosition=False,
     )
     MoveInstrumentComponent(
         Workspace=self.ws_target,
         ComponentName="bank7/sixteenpack",
         X=2.25637,
         Y=-0.814864,
         Z=-0.883485,
         RelativePosition=False,
     )
     MoveInstrumentComponent(
         Workspace=self.ws_target,
         ComponentName="bank42/sixteenpack",
         X=2.58643,
         Y=0.0725628,
         Z=0.0868798,
         RelativePosition=False,
     )
     MoveInstrumentComponent(
         Workspace=self.ws_target,
         ComponentName="bank57/sixteenpack",
         X=0.4545,
         Y=0.0788326,
         Z=2.53234,
         RelativePosition=False,
     )
     # explicitly rotate component TO designated orientation
     RotateInstrumentComponent(
         Workspace=self.ws_target,
         ComponentName="bank7/sixteenpack",
         X=-0.0244456,
         Y=-0.99953,
         Z=-0.0184843,
         Angle=69.4926,
         RelativeRotation=False,
     )
     RotateInstrumentComponent(
         Workspace=self.ws_target,
         ComponentName="bank42/sixteenpack",
         X=-0.011362,
         Y=-0.999935,
         Z=-0.000173303,
         Angle=91.8796,
         RelativeRotation=False,
     )
     RotateInstrumentComponent(
         Workspace=self.ws_target,
         ComponentName="bank42/sixteenpack",
         X=-0.0158497,
         Y=-0.999694,
         Z=0.0189818,
         Angle=169.519,
         RelativeRotation=False,
     )
 def setUp(self):
     # load empty instrument so can create a peak table
     self.ws = LoadEmptyInstrument(InstrumentName='SXD',
                                   OutputWorkspace='empty_SXD')
     axis = self.ws.getAxis(0)
     axis.setUnit("TOF")
示例#24
0
from mantid.simpleapi import LoadEmptyInstrument, MaskBTP, SaveMask

LoadEmptyInstrument(InstrumentName='CORELLI', OutputWorkspace='CORELLI')

# Missing banks
MaskBTP('CORELLI', Bank='1-6,29,30,62,63-68,91')

# End of tubes
MaskBTP('CORELLI', Pixel='1-15,242-256')

# Beam center
MaskBTP('CORELLI', Bank='58', Tube='13-16', Pixel='80-130')
MaskBTP('CORELLI', Bank='59', Tube='1-4', Pixel='80-130')

SaveMask('CORELLI', 'corelli_mask.xml')

示例#25
0
    def setUpClass(cls):
        sans2d_mask_ws = LoadEmptyInstrument(InstrumentName="SANS2D")
        loq_empty = LoadEmptyInstrument(InstrumentName="LOQ")

        cls._sans_original = sans2d_mask_ws
        cls._loq_original = loq_empty
示例#26
0
from mantid.simpleapi import LoadEmptyInstrument, LoadIsawDetCal

cor = LoadEmptyInstrument(InstrumentName='CORELLI')
LoadIsawDetCal(cor, 'SCD_Grouped_calib.results')

i = cor.getInstrument()


def mapBankToABC(i):
    if i < 30:
        return "A" + str(i)
    elif i < 63:
        return "B" + str(i - 29)
    else:
        return "C" + str(i - 62)


print "Location Xsci Ysci Zsci Xrot_sci Yrot_sci Zrot_sci"

for bank in range(1, 92):
    b = i.getComponentByName("bank" + str(bank) + "/sixteenpack")
    x = b.getPos().getX() * 1000
    y = b.getPos().getY() * 1000
    z = b.getPos().getZ() * 1000
    [beta, alpha, gamma] = b.getRotation().getEulerAngles("YXZ")
    print mapBankToABC(bank), x, y, z, alpha, beta, gamma
示例#27
0
    def runTest(self):
        # Na Mn Cl3
        # R -3 H (148)
        # 6.592 6.592 18.585177 90 90 120

        # UB/wavelength from /HFIR/HB3A/IPTS-25470/shared/autoreduce/HB3A_exp0769_scan0040.nxs

        ub = np.array([[1.20297e-01, 1.70416e-01, 1.43000e-04],
                       [8.16000e-04, -8.16000e-04, 5.38040e-02],
                       [1.27324e-01, -4.05110e-02, -4.81000e-04]])

        wavelength = 1.553

        # create fake MDEventWorkspace, similar to what is expected from exp769 after loading with HB3AAdjustSampleNorm
        MD_Q_sample = CreateMDWorkspace(
            Dimensions='3',
            Extents='-5,5,-5,5,-5,5',
            Names='Q_sample_x,Q_sample_y,Q_sample_z',
            Units='rlu,rlu,rlu',
            Frames='QSample,QSample,QSample')

        inst = LoadEmptyInstrument(InstrumentName='HB3A')
        AddTimeSeriesLog(inst, 'omega', '2010-01-01T00:00:00', 0.)
        AddTimeSeriesLog(inst, 'phi', '2010-01-01T00:00:00', 0.)
        AddTimeSeriesLog(inst, 'chi', '2010-01-01T00:00:00', 0.)
        MD_Q_sample.addExperimentInfo(inst)
        SetUB(MD_Q_sample, UB=ub)

        ol = OrientedLattice()
        ol.setUB(ub)

        sg = SpaceGroupFactory.createSpaceGroup("R -3")

        hkl = []
        sat_hkl = []

        for h in range(0, 6):
            for k in range(0, 6):
                for l in range(0, 11):
                    if sg.isAllowedReflection([h, k, l]):
                        if h == k == l == 0:
                            continue
                        q = V3D(h, k, l)
                        q_sample = ol.qFromHKL(q)
                        if not np.any(np.array(q_sample) > 5):
                            hkl.append(q)
                            FakeMDEventData(
                                MD_Q_sample,
                                PeakParams='1000,{},{},{},0.05'.format(
                                    *q_sample))
                        # satellite peaks at 0,0,+1.5
                        q = V3D(h, k, l + 1.5)
                        q_sample = ol.qFromHKL(q)
                        if not np.any(np.array(q_sample) > 5):
                            sat_hkl.append(q)
                            FakeMDEventData(
                                MD_Q_sample,
                                PeakParams='100,{},{},{},0.02'.format(
                                    *q_sample))
                        # satellite peaks at 0,0,-1.5
                        q = V3D(h, k, l - 1.5)
                        q_sample = ol.qFromHKL(q)
                        if not np.any(np.array(q_sample) > 5):
                            sat_hkl.append(q)
                            FakeMDEventData(
                                MD_Q_sample,
                                PeakParams='100,{},{},{},0.02'.format(
                                    *q_sample))

        # Check that this fake workpsace gives us the expected UB
        peaks = FindPeaksMD(MD_Q_sample,
                            PeakDistanceThreshold=1,
                            OutputType='LeanElasticPeak')
        FindUBUsingFFT(peaks, MinD=5, MaxD=20)
        ShowPossibleCells(peaks)
        SelectCellOfType(peaks,
                         CellType='Rhombohedral',
                         Centering='R',
                         Apply=True)
        OptimizeLatticeForCellType(peaks, CellType='Hexagonal', Apply=True)
        found_ol = peaks.sample().getOrientedLattice()
        self.assertAlmostEqual(found_ol.a(), 6.592, places=2)
        self.assertAlmostEqual(found_ol.b(), 6.592, places=2)
        self.assertAlmostEqual(found_ol.c(), 18.585177, places=2)
        self.assertAlmostEqual(found_ol.alpha(), 90)
        self.assertAlmostEqual(found_ol.beta(), 90)
        self.assertAlmostEqual(found_ol.gamma(), 120)

        # nuclear peaks
        predict = HB3APredictPeaks(
            MD_Q_sample,
            Wavelength=wavelength,
            ReflectionCondition='Rhombohedrally centred, obverse',
            SatellitePeaks=True,
            IncludeIntegerHKL=True)
        predict = HB3AIntegratePeaks(MD_Q_sample, predict, 0.25)

        self.assertEqual(predict.getNumberPeaks(), 66)
        # check that the found peaks are expected
        for n in range(predict.getNumberPeaks()):
            HKL = predict.getPeak(n).getHKL()
            self.assertTrue(HKL in hkl, msg=f"Peak {n} with HKL={HKL}")

        # magnetic peaks
        satellites = HB3APredictPeaks(
            MD_Q_sample,
            Wavelength=wavelength,
            ReflectionCondition='Rhombohedrally centred, obverse',
            SatellitePeaks=True,
            ModVector1='0,0,1.5',
            MaxOrder=1,
            IncludeIntegerHKL=False)
        satellites = HB3AIntegratePeaks(MD_Q_sample, satellites, 0.1)

        self.assertEqual(satellites.getNumberPeaks(), 80)
        # check that the found peaks are expected
        for n in range(satellites.getNumberPeaks()):
            HKL = satellites.getPeak(n).getHKL()
            self.assertTrue(HKL in sat_hkl, msg=f"Peak {n} with HKL={HKL}")
示例#28
0
from mantid.simpleapi import LoadEmptyInstrument, AddSampleLog, LoadInstrument
import resource

m0 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
LoadEmptyInstrument(
    Filename='/SNS/users/rwp/wand/IDF/test4/WAND_Definition_fixed.xml',
    OutputWorkspace='wand_fixed')
m1 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
LoadEmptyInstrument(
    Filename='/SNS/users/rwp/wand/IDF/test4/WAND_Definition_2952.xml',
    OutputWorkspace='wand_rect_fixed')
m2 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
LoadEmptyInstrument(
    Filename='/SNS/users/rwp/wand/IDF/test4/WAND_Definition.xml',
    OutputWorkspace='wand')
m3 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
AddSampleLog('wand',
             LogName='HB2C:Mot:s2.RBV',
             LogText='17.57',
             LogType='Number Series')
AddSampleLog('wand',
             LogName='HB2C:Mot:detz.RBV',
             LogText='7.05159',
             LogType='Number Series')
m4 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
LoadInstrument('wand',
               Filename='/SNS/users/rwp/wand/IDF/test4/WAND_Definition.xml',
               RewriteSpectraMap=False)
m5 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss

print(m1 - m0)
示例#29
0
def load_empty_instrument(instrument_name):
    sans_move_test_workspace = LoadEmptyInstrument(
        InstrumentName=instrument_name)
    return sans_move_test_workspace
    logging.basicConfig(format="[%(levelname)s]%(asctime)s:%(message)s",
                        level=logging.INFO)
    #
    lb_bank = 'bank'
    lb_8pack = 'eightpack'
    lb_pos = ['X', 'Y', 'Z']
    df_survey = read_survey_measurements()
    logging.info("Load sanitized survey measurements.")
    logging.info(f"\n{df_survey.groupby(lb_bank)[lb_pos].mean()}")
    for bank_id in df_survey[lb_bank].unique():
        logging.info(
            f"bank_{bank_id}\n{df_survey[df_survey[lb_bank]==bank_id][lb_pos]}"
        )
    #
    logging.info("Loading VULCAN instrument definition.")
    vulcan = LoadEmptyInstrument(Filename="VULCAN_Definition_tmp.xml",
                                 OutputWorkspace="vulcan")
    compInfo = vulcan.componentInfo()
    detInfo = vulcan.detectorInfo()

    # -- Verify banks are in desired quadrants
    #
    #              bank5 | bank4
    #                    |      bank 3
    # bank1------------sample---------->(x) bank2
    #              bank6 |
    #                    v     incident beam
    #                   (z)
    logging.info("Verify banks are in desired quadrants.")
    for name in ['bank1', 'bank2', 'bank3', 'bank4', 'bank5', 'bank6']:
        logging.info(f"Checking {name}")
        bank = getTubeIds(compInfo, name)
示例#31
0
 def _create_instrument(self, instrument_name='IN5'):
     LoadEmptyInstrument(InstrumentName=instrument_name,
                         OutputWorkspace=self._TEST_WS_NAME)
     return mtd[self._TEST_WS_NAME]
示例#32
0
            num_pixel_ids += len(pixel_ids)

    # Use elements defined vs. just group IDs
    group_id_map = collections.OrderedDict()
    for k in groups_map.keys():
        group_id_map[k] = k

    if args.elements:
        assert (len(group_id_map.keys()) == len(args.elements))
        for gid, element in zip(group_ids, args.elements):
            group_id_map[gid] = element

    # Get instrument and detectors
    from mantid.simpleapi import LoadEmptyInstrument, mtd
    wksp = "instrument"
    LoadEmptyInstrument(InstrumentName="NOMAD", OutputWorkspace=wksp)
    instrument = mtd[wksp].getInstrument()

    # Output XYZ file
    with open(args.output, 'w') as f:
        f.write("{}\n\n".format(num_pixel_ids))
        for group_id, pixel_ids in groups_map.items():
            for pixel_idx in pixel_ids:
                x, y, z = instrument.getDetector(pixel_idx).getPos()
                print_args = {
                    'idx': pixel_idx,
                    'x': x,
                    'y': y,
                    'z': z,
                    'group_id': group_id_map[group_id]
                }