diff --git a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/BayesQuasi.py b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/BayesQuasi.py
index cd3908232e0272f728eac9a6c53407b3edce6e3f..06bcfdf855806c9f70b59610e08ac65b41db3c38 100644
--- a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/BayesQuasi.py
+++ b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/BayesQuasi.py
@@ -134,12 +134,7 @@ class BayesQuasi(PythonAlgorithm):
# pylint: disable=too-many-locals,too-many-statements
def PyExec(self):
- # Check for platform support
- if not is_supported_f2py_platform():
- unsupported_msg = "This algorithm can only be run on valid platforms." \
- + " please view the algorithm documentation to see" \
- + " what platforms are currently supported"
- raise RuntimeError(unsupported_msg)
+ self.check_platform_support()
from IndirectBayes import (CalcErange, GetXYE)
setup_prog = Progress(self, start=0.0, end=0.3, nreports=5)
@@ -149,19 +144,13 @@ class BayesQuasi(PythonAlgorithm):
nbins = [self._sam_bins, self._res_bins]
setup_prog.report('Converting to binary for Fortran')
# convert true/false to 1/0 for fortran
- o_el = 1 if self._elastic else 0
- o_w1 = 1 if self._width else 0
- o_res = 1 if self._res_norm else 0
+ o_el = int(self._elastic)
+ o_w1 = int(self._width)
+ o_res = int(self._res_norm)
# fortran code uses background choices defined using the following numbers
setup_prog.report('Encoding input options')
- if self._background == 'Sloping':
- o_bgd = 2
- elif self._background == 'Flat':
- o_bgd = 1
- elif self._background == 'Zero':
- o_bgd = 0
-
+ o_bgd = ['Zero', 'Flat', 'Sloping'].index(self._background)
fitOp = [o_el, o_bgd, o_w1, o_res]
setup_prog.report('Establishing save path')
@@ -182,14 +171,7 @@ class BayesQuasi(PythonAlgorithm):
# Check for trailing and leading zeros in data
setup_prog.report('Checking for leading and trailing zeros in the data')
first_data_point, last_data_point = IndentifyDataBoundaries(self._samWS)
- if first_data_point > self._e_min:
- logger.warning("Sample workspace contains leading zeros within the energy range.")
- logger.warning("Updating eMin: eMin = " + str(first_data_point))
- self._e_min = first_data_point
- if last_data_point < self._e_max:
- logger.warning("Sample workspace contains trailing zeros within the energy range.")
- logger.warning("Updating eMax: eMax = " + str(last_data_point))
- self._e_max = last_data_point
+ self.check_energy_range_for_zeroes(first_data_point, last_data_point)
# update erange with new values
erange = [self._e_min, self._e_max]
@@ -278,26 +260,27 @@ class BayesQuasi(PythonAlgorithm):
nd, xout, yout, eout, yfit, yprob = QLr.qlres(numb, Xv, Yv, Ev, reals, fitOp,
Xdat, Xb, Yb, Wy, We, dtn, xsc,
wrks, wrkr, lwrk)
- message = ' Log(prob) : ' + str(yprob[0]) + ' ' + str(yprob[1]) + ' ' + str(yprob[2]) + ' ' + str(yprob[3])
+ message = ' Log(prob) : ' + str(yprob[0]) + ' ' + str(yprob[1]) + ' ' + str(yprob[2]) + ' ' + str(
+ yprob[3])
logger.information(message)
- if prog == 'QLd':
+ elif prog == 'QLd':
workflow_prog.report('Processing Sample number %i' % spectrum)
nd, xout, yout, eout, yfit, yprob = QLd.qldata(numb, Xv, Yv, Ev, reals, fitOp,
Xdat, Xb, Yb, Eb, Wy, We,
wrks, wrkr, lwrk)
- message = ' Log(prob) : ' + str(yprob[0]) + ' ' + str(yprob[1]) + ' ' + str(yprob[2]) + ' ' + str(yprob[3])
+ message = ' Log(prob) : ' + str(yprob[0]) + ' ' + str(yprob[1]) + ' ' + str(yprob[2]) + ' ' + str(
+ yprob[3])
logger.information(message)
- if prog == 'QSe':
+ elif prog == 'QSe':
workflow_prog.report('Processing Sample number %i as Stretched Exp' % spectrum)
nd, xout, yout, eout, yfit, yprob = Qse.qlstexp(numb, Xv, Yv, Ev, reals, fitOp,
Xdat, Xb, Yb, Wy, We, dtn, xsc,
wrks, wrkr, lwrk)
+
dataX = xout[:nd]
dataX = np.append(dataX, 2 * xout[nd - 1] - xout[nd - 2])
yfit_list = np.split(yfit[:4 * nd], 4)
dataF1 = yfit_list[1]
- if self._program == 'QL':
- dataF2 = yfit_list[2]
workflow_prog.report('Processing data')
dataG = np.zeros(nd)
datX = dataX
@@ -315,6 +298,7 @@ class BayesQuasi(PythonAlgorithm):
res_plot = [0, 1, 2]
if self._program == 'QL':
workflow_prog.report('Processing Lorentzian result data')
+ dataF2 = yfit_list[2]
datX = np.append(datX, dataX)
datY = np.append(datY, dataF2[:nd])
datE = np.append(datE, dataG)
@@ -359,7 +343,7 @@ class BayesQuasi(PythonAlgorithm):
s_api.CreateWorkspace(OutputWorkspace=probWS, DataX=xProb, DataY=yProb, DataE=eProb,
Nspec=3, UnitX='MomentumTransfer')
outWS = self.C2Fw(fname)
- if self._program == 'QSe':
+ elif self._program == 'QSe':
comp_prog.report('Running C2Se')
outWS = self.C2Se(fname)
@@ -386,6 +370,23 @@ class BayesQuasi(PythonAlgorithm):
s_api.SortXAxis(InputWorkspace=probWS, OutputWorkspace=probWS, EnableLogging=False)
self.setProperty('OutputWorkspaceProb', probWS)
+ def check_platform_support(self):
+ if not is_supported_f2py_platform():
+ unsupported_msg = "This algorithm can only be run on valid platforms." \
+ + " please view the algorithm documentation to see" \
+ + " what platforms are currently supported"
+ raise RuntimeError(unsupported_msg)
+
+ def check_energy_range_for_zeroes(self, first_data_point, last_data_point):
+ if first_data_point > self._e_min:
+ logger.warning("Sample workspace contains leading zeros within the energy range.")
+ logger.warning("Updating eMin: eMin = " + str(first_data_point))
+ self._e_min = first_data_point
+ if last_data_point < self._e_max:
+ logger.warning("Sample workspace contains trailing zeros within the energy range.")
+ logger.warning("Updating eMax: eMax = " + str(last_data_point))
+ self._e_max = last_data_point
+
def _add_sample_logs(self, workspace, fit_program, e_range, binning):
sample_binning, res_binning = binning
@@ -458,7 +459,8 @@ class BayesQuasi(PythonAlgorithm):
logger.information('Vaxis=' + str(Vaxis))
s_api.CreateWorkspace(OutputWorkspace=outWS, DataX=dataX, DataY=dataY, DataE=dataE, Nspec=nhist,
- UnitX='MomentumTransfer', VerticalAxisUnit='Text', VerticalAxisValues=Vaxis, YUnitLabel='')
+ UnitX='MomentumTransfer', VerticalAxisUnit='Text', VerticalAxisValues=Vaxis,
+ YUnitLabel='')
return outWS
@@ -643,7 +645,8 @@ class BayesQuasi(PythonAlgorithm):
e = np.asarray(e).flatten()
s_api.CreateWorkspace(OutputWorkspace=output_workspace, DataX=x, DataY=y, DataE=e, Nspec=num_spectra,
- UnitX='MomentumTransfer', YUnitLabel='', VerticalAxisUnit='Text', VerticalAxisValues=axis_names)
+ UnitX='MomentumTransfer', YUnitLabel='', VerticalAxisUnit='Text',
+ VerticalAxisValues=axis_names)
return output_workspace
diff --git a/Testing/SystemTests/tests/analysis/Peak2ConvCell_Test.py b/Testing/SystemTests/tests/analysis/Peak2ConvCell_Test.py
index 6ae9aadd202d880bead36959f73e10b397746487..884a83cf24e1ebafc570a686f3c83b1b0bdd43b8 100644
--- a/Testing/SystemTests/tests/analysis/Peak2ConvCell_Test.py
+++ b/Testing/SystemTests/tests/analysis/Peak2ConvCell_Test.py
@@ -157,6 +157,56 @@ class Peak2ConvCell_Test(object): # (stresstesting.MantidStressTest):
return RUB.I
+ @staticmethod
+ def _calc_result_center_I(res, res_p):
+ s1 = 1
+ s2 = 1
+ for r in range(0, 3):
+ for cc in range(3):
+
+ if cc == 0:
+ if r > 0:
+ s1 = (-1) ** r
+ s2 = -s1
+
+ res[r, cc] = res_p[0, cc] / 2 + s1 * res_p[1, cc] / 2 + s2 * res_p[2, cc] / 2
+
+ return res.I
+
+ @staticmethod
+ def _calc_result_center_F(res, res_p):
+ ss = [0, 0, 0]
+
+ for r in range(3):
+ for cc in range(3):
+ ss = [1, 1, 1]
+ ss[r] = 0
+
+ res[r, cc] = ss[0] * res_p[0, cc] / 2 + ss[1] * res_p[1, cc] / 2 + ss[2] * res_p[2, cc] / 2
+
+ return res.I
+
+ @staticmethod
+ def _calc_result_center_ABC(res, res_p, r):
+ k = 0
+
+ res[r, 0] = res_p[r, 0]
+ res[r, 1] = res_p[r, 1]
+ res[r, 2] = res_p[r, 2]
+ for i in range(1, 3):
+
+ if k == r:
+ k += 1
+ for cc in range(3):
+ R = (r + 1) % 3
+ s = (-1) ** i
+
+ res[k, cc] = res_p[(R) % 3, cc] / 2 + s * res_p[(R + 1) % 3, cc] / 2
+
+ k += 1
+
+ return res.I
+
def CalcNiggliUB(self, a, b, c, alpha, beta, gamma, celltype, Center):
if Center == 'P':
@@ -175,36 +225,14 @@ class Peak2ConvCell_Test(object): # (stresstesting.MantidStressTest):
Center = 'R'
if Center == 'I':
-
- s1 = 1
- s2 = 1
- for r in range(0, 3):
- for cc in range(3):
-
- if cc == 0:
- if r > 0:
- s1 = (-1) ** r
- s2 = -s1
-
- Res[r, cc] = ResP[0, cc] / 2 + s1 * ResP[1, cc] / 2 + s2 * ResP[2, cc] / 2
-
- Res = Res.I
+ Res = Peak2ConvCell_Test._calc_result_center_I(Res, ResP)
elif Center == 'F':
if celltype == 'H' or celltype == 'M':
return None
- ss = [0, 0, 0]
-
- for r in range(3):
- for cc in range(3):
- ss = [1, 1, 1]
- ss[r] = 0
-
- Res[r, cc] = ss[0] * ResP[0, cc] / 2 + ss[1] * ResP[1, cc] / 2 + ss[2] * ResP[2, cc] / 2
-
- Res = Res.I
+ Res = Peak2ConvCell_Test._calc_result_center_F(Res, ResP)
elif Center == 'A' or Center == 'B' or Center == 'C':
@@ -229,24 +257,7 @@ class Peak2ConvCell_Test(object): # (stresstesting.MantidStressTest):
elif a == b and celltype == 'O':
return None
- k = 0
-
- Res[r, 0] = ResP[r, 0]
- Res[r, 1] = ResP[r, 1]
- Res[r, 2] = ResP[r, 2]
- for i in range(1, 3):
-
- if k == r:
- k += 1
- for cc in range(3):
- R = (r + 1) % 3
- s = (-1) ** i
-
- Res[k, cc] = ResP[(R) % 3, cc] / 2 + s * ResP[(R + 1) % 3, cc] / 2
-
- k += 1
-
- Res = Res.I
+ Res = Peak2ConvCell_Test._calc_result_center_ABC(Res, ResP, r)
elif Center == 'R':
@@ -258,12 +269,6 @@ class Peak2ConvCell_Test(object): # (stresstesting.MantidStressTest):
# Did not work with 0 error. FindUBUsingFFT failed
# Alpha = alpha*math.pi/180
- # Res[0,0] = a
- # Res[1,0] =(a*math.cos( Alpha ))
- # Res[1,1] = (a*math.sin( Alpha ))
- # Res[2,0] =(a*math.cos( Alpha ))
- # Res[2,1] =(a*Res[1,0] -Res[2,0]*Res[1,0])/Res[1,1]
- # Res[2,2] =math.sqrt( a*a- Res[2,1]*Res[2,1]-Res[2,0]*Res[2,0])
Res[0, 0] = .5 * a
Res[0, 1] = math.sqrt(3) * a / 2
Res[0, 2] = .5 * b
diff --git a/scripts/Calibration/tube.py b/scripts/Calibration/tube.py
index f1ecadbad68f4a19b1071ff5c0bed60126fd3a1c..f246abcfbf3e0014e8331b21947c51312f4cc65e 100644
--- a/scripts/Calibration/tube.py
+++ b/scripts/Calibration/tube.py
@@ -76,10 +76,10 @@ def calibrate(ws, tubeSet, knownPositions, funcForm, **kwargs):
Define the calibrated positions of the detectors inside the tubes defined
in tubeSet.
- Tubes may be considered a list of detectors alined that may be considered
+ Tubes may be considered a list of detectors aligned that may be considered
as pixels for the analogy when they values are displayed.
- The position of these pixels are provided by the manufactor, but its real
+ The position of these pixels are provided by the manufacturer, but its real
position depends on the electronics inside the tube and varies slightly
from tube to tube. The calibrate method, aims to find the real positions
of the detectors (pixels) inside the tube.
@@ -351,13 +351,13 @@ def calibrate(ws, tubeSet, knownPositions, funcForm, **kwargs):
# skip finding peaks
fit_peaks_to_position()
- :param fitPolyn: Define the order of the polinomial to fit the pixels positions agains the known positions. The \
+ :param fitPolyn: Define the order of the polynomial to fit the pixels positions against the known positions. The \
acceptable values are 1, 2 or 3. Default = 2.
:param outputPeak: Enable the calibrate to output the peak table, relating the tubes with the pixels positions. It \
may be passed as a boolean value (outputPeak=True) or as a peakTable value. The later case is to inform calibrate \
- to append the new values to the given peakTable. This is usefull when you have to operate in subsets of tubes. \
+ to append the new values to the given peakTable. This is useful when you have to operate in subsets of tubes. \
(see :py:mod:`~Examples.TubeCalibDemoMerlin` that shows a nice inspection on this table).
.. code-block:: python
@@ -382,236 +382,60 @@ def calibrate(ws, tubeSet, knownPositions, funcForm, **kwargs):
FITPOLIN = 'fitPolyn'
OUTPUTPEAK = 'outputPeak'
+ param_helper = _CalibrationParameterHelper(FITPAR, MARGIN, RANGELIST, CALIBTABLE, PLOTTUBE, EXCLUDESHORT,
+ OVERRIDEPEAKS, FITPOLIN, OUTPUTPEAK)
+
# check that only valid arguments were passed through kwargs
- for key in kwargs.keys():
- if key not in [FITPAR, MARGIN, RANGELIST, CALIBTABLE, PLOTTUBE,
- EXCLUDESHORT, OVERRIDEPEAKS, FITPOLIN,
- OUTPUTPEAK]:
- msg = "Wrong argument: '%s'! This argument is not defined in the signature of this function. Hint: remember" \
- "that arguments are case sensitive" % key
- raise RuntimeError(msg)
+ param_helper.ensure_no_unknown_kwargs(kwargs)
# check parameter ws: if it was given as string, transform it in
# mantid object
- if isinstance(ws, str):
- ws = mtd[ws]
- if not isinstance(ws, MatrixWorkspace):
- raise RuntimeError("Wrong argument ws = %s. It must be a MatrixWorkspace" % (str(ws)))
+ ws = _CalibrationParameterHelper.enforce_matrix_ws(ws)
# check parameter tubeSet. It accepts string or preferable a TubeSpec
- if isinstance(tubeSet, str):
- selectedTubes = tubeSet
- tubeSet = TubeSpec(ws)
- tubeSet.setTubeSpecByString(selectedTubes)
- elif isinstance(tubeSet, list):
- selectedTubes = tubeSet
- tubeSet = TubeSpec(ws)
- tubeSet.setTubeSpecByStringArray(selectedTubes)
- elif not isinstance(tubeSet, TubeSpec):
- raise RuntimeError(
- "Wrong argument tubeSet. It must be a TubeSpec or a string that defines the set of tubes to be calibrated."
- "For example: WISH/panel03")
+ tubeSet = _CalibrationParameterHelper.enforce_tube_spec(tubeSet, ws)
# check the known_positions parameter
- # for old version compatibility, it also accepts IdealTube, eventhough
+ # for old version compatibility, it also accepts IdealTube, even though
# they should only be used internally
- if not (isinstance(knownPositions, list) or isinstance(knownPositions, tuple) or isinstance(knownPositions, numpy.ndarray)):
- raise RuntimeError(
- "Wrong argument knownPositions. It expects a list of values for the positions expected for the peaks in"
- "relation to the center of the tube")
- else:
- idealTube = IdealTube()
- idealTube.setArray(numpy.array(knownPositions))
-
- for val in knownPositions:
- if val >= 100:
- # Tube is greater than 100m - this is probably wrong so print an error
- raise ValueError("The following value: " + str(val) + " is greater or equal than 100m in length"
- "\nHave you remembered to convert to meters?")
+ _CalibrationParameterHelper.validate_known_positions(knownPositions)
+ ideal_tube = IdealTube()
+ ideal_tube.setArray(numpy.array(knownPositions))
+ n_peaks = len(ideal_tube.getArray())
# deal with funcForm parameter
- try:
- nPeaks = len(idealTube.getArray())
- if len(funcForm) != nPeaks:
- raise 1
- for val in funcForm:
- if val not in [1, 2]:
- raise 2
- except:
- raise RuntimeError(
- "Wrong argument FuncForm. It expects a list of values describing the form of everysingle peaks. So, for"
- "example, if there are three peaks where the first is a peak and the followers as edge,"
- "funcForm = [1, 2, 2].Currently, it is defined 1-Gaussian Peak, 2 - Edge. The knownPos has %d elements"
- "and the given funcForm has %d." % (nPeaks, len(funcForm)))
+ _CalibrationParameterHelper.validate_func_form(funcForm, n_peaks)
# apply the functional form to the ideal Tube
- idealTube.setForm(funcForm)
+ ideal_tube.setForm(funcForm)
# check the FITPAR parameter (optional)
# if the FITPAR is given, than it will just pass on, if the FITPAR is
# not given, it will create a FITPAR 'guessing' the centre positions,
# and allowing the find peaks calibration methods to adjust the parameter
# for the peaks automatically
- if FITPAR in kwargs:
- fitPar = kwargs[FITPAR]
- # fitPar must be a TubeCalibFitParams
- if not isinstance(fitPar, TubeCalibFitParams):
- raise RuntimeError(
- "Wrong argument %s. This argument, when given, must be a valid TubeCalibFitParams object" % FITPAR)
- else:
- # create a fit parameters guessing centre positions
- # the guessing obeys the following rule:
- #
- # centre_pixel = known_pos * ndets/tube_length + ndets / 2
- #
- # Get tube length and number of detectors
- tube_length = tubeSet.getTubeLength(0)
- # ndets = len(wsp_index_for_tube0)
- dummy_id1, ndets, dummy_step = tubeSet.getDetectorInfoFromTube(0)
-
- known_pos = idealTube.getArray()
- # position of the peaks in pixels
- centre_pixel = known_pos * ndets / tube_length + ndets * 0.5
-
- fitPar = TubeCalibFitParams(centre_pixel)
- # make it automatic, it means, that for every tube,
- # the parameters for fit will be re-evaluated, from the first
- # guess positions given by centre_pixel
- fitPar.setAutomatic(True)
-
- # check the MARGIN paramter (optional)
- if MARGIN in kwargs:
- try:
- margin = float(kwargs[MARGIN])
- except:
- raise RuntimeError("Wrong argument %s. It was expected a number!" % MARGIN)
- fitPar.setMargin(margin)
-
- # deal with RANGELIST parameter
- if RANGELIST in kwargs:
- rangeList = kwargs[RANGELIST]
- if isinstance(rangeList, int):
- rangeList = [rangeList]
- try:
- # this deals with list and tuples and iterables to make sure
- # rangeList becomes a list
- rangeList = list(rangeList)
- except:
- raise RuntimeError("Wrong argument %s. It expects a list of indexes for calibration" % RANGELIST)
- else:
- rangeList = range(tubeSet.getNumTubes())
-
- # check if the user passed the option calibTable
- if CALIBTABLE in kwargs:
- calibTable = kwargs[CALIBTABLE]
- # ensure the correct type is passed
- # if a string was passed, transform it in mantid object
- if isinstance(calibTable, str):
- calibTable = mtd[calibTable]
- # check that calibTable has the expected form
- try:
- if not isinstance(calibTable, ITableWorkspace):
- raise 1
- if calibTable.columnCount() != 2:
- raise 2
- colNames = calibTable.getColumnNames()
- if colNames[0] != 'Detector ID' or colNames[1] != 'Detector Position':
- raise 3
- except:
- raise RuntimeError(
- "Invalid type for %s. The expected type was ITableWorkspace with 2 columns(Detector ID and Detector"
- "Positions)" % CALIBTABLE)
- else:
- calibTable = CreateEmptyTableWorkspace(OutputWorkspace="CalibTable")
- # "Detector ID" column required by ApplyCalibration
- calibTable.addColumn(type="int", name="Detector ID")
- # "Detector Position" column required by ApplyCalibration
- calibTable.addColumn(type="V3D", name="Detector Position")
-
- # deal with plotTube option
- if PLOTTUBE in kwargs:
- plotTube = kwargs[PLOTTUBE]
- if isinstance(plotTube, int):
- plotTube = [plotTube]
- try:
- plotTube = list(plotTube)
- except:
- raise RuntimeError("Wrong argument %s. It expects an index (int) or a list of indexes" % PLOTTUBE)
- else:
- plotTube = []
-
- # deal with minimun tubes sizes
- if EXCLUDESHORT in kwargs:
- excludeShortTubes = kwargs[EXCLUDESHORT]
- try:
- excludeShortTubes = float(excludeShortTubes)
- except:
- raise RuntimeError(
- "Wrong argument %s. It expects a float value for the minimun size of tubes to be calibrated")
- else:
- # a tube with length 0 can not be calibrated, this is the minimun value
- excludeShortTubes = 0.0
-
- # deal with OVERRIDEPEAKS parameters
- if OVERRIDEPEAKS in kwargs:
- overridePeaks = kwargs[OVERRIDEPEAKS]
- try:
- nPeaks = len(idealTube.getArray())
- # check the format of override peaks
- if not isinstance(overridePeaks, dict):
- raise 1
- for key in overridePeaks.keys():
- if not isinstance(key, int):
- raise 2
- if key < 0 or key >= tubeSet.getNumTubes():
- raise 3
- if len(overridePeaks[key]) != nPeaks:
- raise 4
- except:
- raise RuntimeError(
- "Wrong argument %s. It expects a dictionary with key as the tube index and the value as a list of peaks"
- "positions. Ex (3 peaks): overridePeaks = {1:[2,5.4,500]}" % OVERRIDEPEAKS)
- else:
- overridePeaks = dict()
-
- # deal with FITPOLIN parameter
- if FITPOLIN in kwargs:
- polinFit = kwargs[FITPOLIN]
- if polinFit not in [1, 2, 3]:
- raise RuntimeError(
- "Wrong argument %s. It expects a number 1 for linear, 2 for quadratic, or 3 for 3rd polinomial order"
- "when fitting the pixels positions agains the known positions" % FITPOLIN)
- else:
- polinFit = 2
+ fit_par = param_helper.get_parameter(FITPAR, kwargs, tube_set=tubeSet, ideal_tube=ideal_tube)
- # deal with OUTPUT PEAK
- deletePeakTableAfter = False
- if OUTPUTPEAK in kwargs:
- outputPeak = kwargs[OUTPUTPEAK]
- else:
- outputPeak = False
- if isinstance(outputPeak, ITableWorkspace):
- if outputPeak.columnCount() < len(idealTube.getArray()):
- raise RuntimeError(
- "Wrong argument %s. It expects a boolean flag, or a ITableWorksapce with columns (TubeId, Peak1,...,"
- "PeakM) for M = number of peaks given in knownPositions" % OUTPUTPEAK)
- else:
- if not outputPeak:
- deletePeakTableAfter = True
- # create the output peak table
- outputPeak = CreateEmptyTableWorkspace(OutputWorkspace="PeakTable")
- outputPeak.addColumn(type='str', name='TubeId')
- for i in range(len(idealTube.getArray())):
- outputPeak.addColumn(type='float', name='Peak%d' % (i + 1))
-
- getCalibration(ws, tubeSet, calibTable, fitPar, idealTube, outputPeak,
- overridePeaks, excludeShortTubes, plotTube, rangeList, polinFit)
-
- if deletePeakTableAfter:
- DeleteWorkspace(str(outputPeak))
- return calibTable
+ if MARGIN in kwargs:
+ margin = param_helper.get_parameter(MARGIN, kwargs)
+ fit_par.setMargin(margin)
+
+ range_list = param_helper.get_parameter(RANGELIST, kwargs, default_range_list=tubeSet.getNumTubes())
+ calib_table = param_helper.get_parameter(CALIBTABLE, kwargs)
+ plot_tube = param_helper.get_parameter(PLOTTUBE, kwargs)
+ exclude_short_tubes = param_helper.get_parameter(EXCLUDESHORT, kwargs)
+ override_peaks = param_helper.get_parameter(OVERRIDEPEAKS, kwargs, tube_set=tubeSet, ideal_tube=ideal_tube)
+ polin_fit = param_helper.get_parameter(FITPOLIN, kwargs)
+ output_peak, delete_peak_table_after = param_helper.get_parameter(OUTPUTPEAK, kwargs, ideal_tube=ideal_tube)
+
+ getCalibration(ws, tubeSet, calib_table, fit_par, ideal_tube, output_peak,
+ override_peaks, exclude_short_tubes, plot_tube, range_list, polin_fit)
+
+ if delete_peak_table_after:
+ DeleteWorkspace(str(output_peak))
+ return calib_table
else:
- return calibTable, outputPeak
+ return calib_table, output_peak
def savePeak(peakTable, filePath):
@@ -861,3 +685,282 @@ def correctMisalignedTubes(ws, calibrationTable, peaksTable, spec, idealTube,
cleanUpFit()
return corrections_table
+
+
+class _CalibrationParameterHelper(object):
+
+ def __init__(self, FITPAR, MARGIN, RANGELIST, CALIBTABLE, PLOTTUBE, EXCLUDESHORT, OVERRIDEPEAKS, FITPOLIN,
+ OUTPUTPEAK):
+ self.FITPAR = FITPAR
+ self.MARGIN = MARGIN
+ self.RANGELIST = RANGELIST
+ self.CALIBTABLE = CALIBTABLE
+ self.PLOTTUBE = PLOTTUBE
+ self.EXCLUDESHORT = EXCLUDESHORT
+ self.OVERRIDEPEAKS = OVERRIDEPEAKS
+ self.FITPOLIN = FITPOLIN
+ self.OUTPUTPEAK = OUTPUTPEAK
+ self.allowed_kwargs = {FITPAR, MARGIN, RANGELIST, CALIBTABLE, PLOTTUBE, EXCLUDESHORT, OVERRIDEPEAKS, FITPOLIN,
+ OUTPUTPEAK}
+
+ def ensure_no_unknown_kwargs(self, kwargs):
+ for key in kwargs.keys():
+ if key not in self.allowed_kwargs:
+ msg = "Wrong argument: '{0}'! This argument is not defined in the signature of this function. Hint: remember" \
+ "that arguments are case sensitive".format(key)
+ raise RuntimeError(msg)
+
+ @staticmethod
+ def enforce_matrix_ws(ws):
+ if isinstance(ws, MatrixWorkspace):
+ return ws
+ if isinstance(ws, str):
+ return mtd[ws]
+ raise RuntimeError("Wrong argument ws = %s. It must be a MatrixWorkspace" % (str(ws)))
+
+ @staticmethod
+ def enforce_tube_spec(tube_set, ws):
+ if isinstance(tube_set, str):
+ selected_tubes = tube_set
+ tube_set = TubeSpec(ws)
+ tube_set.setTubeSpecByString(selected_tubes)
+ return tube_set
+ if isinstance(tube_set, list):
+ selected_tubes = tube_set
+ tube_set = TubeSpec(ws)
+ tube_set.setTubeSpecByStringArray(selected_tubes)
+ return tube_set
+ if isinstance(tube_set, TubeSpec):
+ return tube_set
+ raise RuntimeError("Wrong argument tubeSet. "
+ "It must be a TubeSpec or a string that defines the set of tubes to be calibrated. "
+ "For example: WISH/panel03")
+
+ @staticmethod
+ def validate_known_positions(known_positions):
+ if not (isinstance(known_positions, list) or
+ isinstance(known_positions, tuple) or
+ isinstance(known_positions, numpy.ndarray)):
+ raise RuntimeError(
+ "Wrong argument knownPositions. It expects a list of values for the positions expected for the peaks in"
+ "relation to the center of the tube")
+
+ for val in known_positions:
+ if val >= 100:
+ # Tube is greater than 100m - this is probably wrong so print an error
+ raise ValueError("The following value: " + str(val) + " is greater or equal than 100m in length"
+ "\nHave you remembered to convert to meters?")
+
+ @staticmethod
+ def validate_func_form(func_form, n_peaks):
+ try:
+ if len(func_form) != n_peaks:
+ raise 1
+ for val in func_form:
+ if val not in [1, 2]:
+ raise 2
+ except:
+ raise RuntimeError(
+ "Wrong argument FuncForm. It expects a list of values describing the form of everysingle peaks. So, for"
+ "example, if there are three peaks where the first is a peak and the followers as edge,"
+ "funcForm = [1, 2, 2].Currently, it is defined 1-Gaussian Peak, 2 - Edge. The knownPos has %d elements"
+ "and the given funcForm has %d." % (n_peaks, len(func_form)))
+
+ def get_parameter(self, name, args, **kwargs):
+ if name == self.FITPAR:
+ return self._get_fit_par(args, tube_set=kwargs["tube_set"], ideal_tube=kwargs["ideal_tube"])
+ if name == self.MARGIN:
+ return self._get_margin(args)
+ if name == self.RANGELIST:
+ return self._get_range_list(args, default_range_list=kwargs["default_range_list"])
+ if name == self.CALIBTABLE:
+ return self._get_calib_table(args)
+ if name == self.PLOTTUBE:
+ return self._get_plot_tube(args)
+ if name == self.EXCLUDESHORT:
+ return self._get_exclude_short(args)
+ if name == self.OVERRIDEPEAKS:
+ return self._get_override_peaks(args, tube_set=kwargs["tube_set"], ideal_tube=kwargs["ideal_tube"])
+ if name == self.OUTPUTPEAK:
+ return self._get_output_peak(args, ideal_tube=kwargs["ideal_tube"])
+ if name == self.FITPOLIN:
+ return self._get_fit_polin(args)
+
+ def _get_output_peak(self, args, ideal_tube):
+ delete_peak_table_after = False
+ if self.OUTPUTPEAK in args:
+ output_peak = args[self.OUTPUTPEAK]
+ else:
+ output_peak = False
+
+ if isinstance(output_peak, ITableWorkspace):
+ if output_peak.columnCount() < len(ideal_tube.getArray()):
+ raise RuntimeError(
+ "Wrong argument {0}. "
+ "It expects a boolean flag, or a ITableWorksapce with columns (TubeId, Peak1,...,"
+ "PeakM) for M = number of peaks given in knownPositions".format(self.OUTPUTPEAK))
+ return output_peak, delete_peak_table_after
+
+ else:
+ if not output_peak:
+ delete_peak_table_after = True
+
+ # create the output peak table
+ output_peak = CreateEmptyTableWorkspace(OutputWorkspace="PeakTable")
+ output_peak.addColumn(type='str', name='TubeId')
+ for i in range(len(ideal_tube.getArray())):
+ output_peak.addColumn(type='float', name='Peak%d' % (i + 1))
+ return output_peak, delete_peak_table_after
+
+ def _get_fit_polin(self, args):
+ if self.FITPOLIN in args:
+ polin_fit = args[self.FITPOLIN]
+ if polin_fit not in [1, 2, 3]:
+ raise RuntimeError(
+ "Wrong argument {0}. "
+ "It expects a number 1 for linear, 2 for quadratic, or 3 for 3rd polinomial order"
+ "when fitting the pixels positions agains the known positions".format(self.FITPOLIN))
+ else:
+ return polin_fit
+ else:
+ return 2
+
+ def _get_override_peaks(self, args, tube_set, ideal_tube):
+ if self.OVERRIDEPEAKS in args:
+ override_peaks = args[self.OVERRIDEPEAKS]
+ try:
+ n_peaks = len(ideal_tube.getArray())
+ # check the format of override peaks
+ if not isinstance(override_peaks, dict):
+ raise 1
+ for key in override_peaks.keys():
+ if not isinstance(key, int):
+ raise 2
+ if key < 0 or key >= tube_set.getNumTubes():
+ raise 3
+ if len(override_peaks[key]) != n_peaks:
+ raise 4
+ except:
+ raise RuntimeError(
+ "Wrong argument {0}. "
+ "It expects a dictionary with key as the tube index and the value as a list of peaks positions. "
+ "Ex (3 peaks): override_peaks = {1:[2,5.4,500]}".format(self.OVERRIDEPEAKS))
+ else:
+ return override_peaks
+ else:
+ return dict()
+
+ def _get_exclude_short(self, args):
+ if self.EXCLUDESHORT in args:
+ exclude_short_tubes = args[self.EXCLUDESHORT]
+ try:
+ exclude_short_tubes = float(exclude_short_tubes)
+ except:
+ raise RuntimeError(
+ "Wrong argument {0}. It expects a float value for the minimun size of tubes to be calibrated".
+ format(self.EXCLUDESHORT))
+ else:
+ return exclude_short_tubes
+ else:
+ # a tube with length 0 can not be calibrated, this is the minimun value
+ return 0.0
+
+ def _get_plot_tube(self, args):
+ if self.PLOTTUBE in args:
+ plot_tube = args[self.PLOTTUBE]
+ if isinstance(plot_tube, int):
+ plot_tube = [plot_tube]
+ try:
+ plot_tube = list(plot_tube)
+ except:
+ raise RuntimeError("Wrong argument {0}. It expects an index (int) or a list of indexes".
+ format(self.PLOTTUBE))
+ else:
+ return plot_tube
+ else:
+ return []
+
+ def _get_calib_table(self, args):
+ if self.CALIBTABLE in args:
+ calib_table = args[self.CALIBTABLE]
+ # ensure the correct type is passed
+ # if a string was passed, transform it in mantid object
+ if isinstance(calib_table, str):
+ calib_table = mtd[calib_table]
+ # check that calibTable has the expected form
+ try:
+ if not isinstance(calib_table, ITableWorkspace):
+ raise 1
+ if calib_table.columnCount() != 2:
+ raise 2
+ colNames = calib_table.getColumnNames()
+ if colNames[0] != 'Detector ID' or colNames[1] != 'Detector Position':
+ raise 3
+ except:
+ raise RuntimeError(
+ "Invalid type for {0}."
+ "The expected type was ITableWorkspace with 2 columns(Detector ID and Detector Positions)".
+ format(self.CALIBTABLE))
+ else:
+ return calib_table
+ else:
+ calib_table = CreateEmptyTableWorkspace(OutputWorkspace="CalibTable")
+ # "Detector ID" column required by ApplyCalibration
+ calib_table.addColumn(type="int", name="Detector ID")
+ # "Detector Position" column required by ApplyCalibration
+ calib_table.addColumn(type="V3D", name="Detector Position")
+ return calib_table
+
+ def _get_range_list(self, args, default_range_list):
+ if self.RANGELIST in args:
+ range_list = args[self.RANGELIST]
+ if isinstance(range_list, int):
+ range_list = range_list
+ try:
+ # this deals with list and tuples and iterables to make sure
+ # range_list becomes a list
+ range_list = list(range_list)
+ except:
+ raise RuntimeError("Wrong argument {0}. It expects a list of indexes for calibration".
+ format(self.RANGELIST))
+ else:
+ return range_list
+ else:
+ return default_range_list
+
+ def _get_margin(self, args):
+ try:
+ return float(args[self.MARGIN])
+ except:
+ raise RuntimeError("Wrong argument {0}. It was expected a number!".format(self.MARGIN))
+
+ def _get_fit_par(self, args, tube_set, ideal_tube):
+ if self.FITPAR in args:
+ fit_par = args[self.FITPAR]
+ # fitPar must be a TubeCalibFitParams
+ if not isinstance(fit_par, TubeCalibFitParams):
+ raise RuntimeError(
+ "Wrong argument {0}. This argument, when given, must be a valid TubeCalibFitParams object".
+ format(self.FITPAR))
+ else:
+ # create a fit parameters guessing centre positions
+ # the guessing obeys the following rule:
+ #
+ # centre_pixel = known_pos * ndets/tube_length + ndets / 2
+ #
+ # Get tube length and number of detectors
+ tube_length = tube_set.getTubeLength(0)
+ # ndets = len(wsp_index_for_tube0)
+ dummy_id1, ndets, dummy_step = tube_set.getDetectorInfoFromTube(0)
+
+ known_pos = ideal_tube.getArray()
+ # position of the peaks in pixels
+ centre_pixel = known_pos * ndets / tube_length + ndets * 0.5
+
+ fit_par = TubeCalibFitParams(centre_pixel)
+ # make it automatic, it means, that for every tube,
+ # the parameters for fit will be re-evaluated, from the first
+ # guess positions given by centre_pixel
+ fit_par.setAutomatic(True)
+
+ return fit_par
diff --git a/scripts/Calibration/tube_calib.py b/scripts/Calibration/tube_calib.py
index ae16b409cd60e4865d0bcfe765b3bcc625ea1a0b..b36cf00f60926f25c689881696a3c4aaf4ca5363 100644
--- a/scripts/Calibration/tube_calib.py
+++ b/scripts/Calibration/tube_calib.py
@@ -1,4 +1,3 @@
-#pylint: disable=invalid-name
"""
This file is concerned with calibrating a specified set of tubes
@@ -23,115 +22,114 @@ import os
import copy
-def createTubeCalibtationWorkspaceByWorkspaceIndexList ( integratedWorkspace, outputWorkspace, workspaceIndexList,
- xUnit='Pixel', showPlot=False):
+def create_tube_calibration_ws_by_ws_index_list(integrated_workspace, output_workspace, workspace_index_list):
"""
Creates workspace with integrated data for one tube against distance along tube
The tube is specified by a list of workspace indices of its spectra
- @param IntegratedWorkspace: Workspace of integrated data
- @param workspaceIndexList: list of workspace indices for the tube
- @param xUnit: unit of distance ( Pixel)
- @param showPlot: True = show plot of workspace created, False = just make the workspace.
+ @param integrated_workspace: Workspace of integrated data
+ @param workspace_index_list: list of workspace indices for the tube
+ @param x_unit: unit of distance ( Pixel)
+ @param show_plot: True = show plot of workspace created, False = just make the workspace.
Return Value: Workspace created
"""
- nSpectra = len(workspaceIndexList)
- if nSpectra < 1:
+ n_spectra = len(workspace_index_list)
+ if n_spectra < 1:
return
- pixelNumbers = []
- integratedPixelCounts = []
+ pixel_numbers = []
+ integrated_pixel_counts = []
pixel = 1
- #integratedWorkspace.
- for i in workspaceIndexList:
- pixelNumbers.append(pixel)
+ # integratedWorkspace.
+ for i in workspace_index_list:
+ pixel_numbers.append(pixel)
pixel = pixel + 1
- integratedPixelCounts.append( integratedWorkspace.dataY(i)[0] )
+ integrated_pixel_counts.append(integrated_workspace.dataY(i)[0])
- CreateWorkspace(dataX=pixelNumbers,dataY=integratedPixelCounts, OutputWorkspace=outputWorkspace)
- #if (showPlot):
- #plotSpectrum(outputWorkspace,0)
- # For some reason plotSpectrum is not recognised, but instead we can plot this worspace afterwards.
+ CreateWorkspace(dataX=pixel_numbers, dataY=integrated_pixel_counts, OutputWorkspace=output_workspace)
+ # For some reason plotSpectrum is not recognised, but instead we can plot this workspace afterwards.
# Return the udet number and [x,y,z] position of the detector (or virtual detector) corresponding to spectra spectra_number
# Thanks to Pascal Manuel for this function
-def get_detector_pos(work_handle,spectra_number):
- udet=work_handle.getDetector(spectra_number)
+def get_detector_pos(work_handle, spectra_number):
+ udet = work_handle.getDetector(spectra_number)
return udet.getID(), udet.getPos()
+
# Given the center of a slit in pixels return the interpolated y
# Converts from pixel coords to Y.
# If a pixel coord is not integer
# it is effectively rounded to half integer before conversion, rather than interpolated.
# It allows the pixel widths to vary (unlike correctTube).
# Thanks to Pascal Manuel for this function
-
-
-def get_ypos(work_handle,pixel_float):
- center_low_pixel=int(math.floor(pixel_float))
- center_high_pixel=int(math.ceil(pixel_float))
- idlow, low=get_detector_pos(work_handle,center_low_pixel) #Get the detector position of the nearest lower pixel
- idhigh, high=get_detector_pos(work_handle,center_high_pixel) #Get the detector position of the nearest higher pixel
- center_y=(center_high_pixel-pixel_float)*low.getY()+(pixel_float-center_low_pixel)*high.getY()
- center_y/=(center_high_pixel-center_low_pixel)
+def get_ypos(work_handle, pixel_float):
+ center_low_pixel = int(math.floor(pixel_float))
+ center_high_pixel = int(math.ceil(pixel_float))
+ idlow, low = get_detector_pos(work_handle, center_low_pixel) # Get the detector position of the nearest lower pixel
+ idhigh, high = get_detector_pos(work_handle,
+ center_high_pixel) # Get the detector position of the nearest higher pixel
+ center_y = (center_high_pixel - pixel_float) * low.getY() + (pixel_float - center_low_pixel) * high.getY()
+ center_y /= (center_high_pixel - center_low_pixel)
return center_y
-def fitGaussianParams ( height, centre, sigma ): # Compose string argument for fit
- return "name=Gaussian, Height="+str(height)+", PeakCentre="+str(centre)+", Sigma="+str(sigma)
+def fit_gaussian_params(height, centre, sigma): # Compose string argument for fit
+ return "name=Gaussian, Height={0}, PeakCentre={1}, Sigma={2}".format(height, centre, sigma)
+
+def fit_end_erfc_params(B, C): # Compose string argument for fit
+ return "name=EndErfc, B={0}, C={1}".format(B, C)
-def fitEndErfcParams ( B, C ): # Compose string argument for fit
- return "name=EndErfc, B="+str(B)+", C="+str(C)
#
# definition of the functions to fit
#
-def fitEdges(fitPar, index, ws, outputWs):
+def fit_edges(fit_par, index, ws, output_ws):
# find the edge position
- centre = fitPar.getPeaks()[index]
- outedge, inedge, endGrad = fitPar.getEdgeParameters()
- margin = fitPar.getMargin()
- #get values around the expected center
+ centre = fit_par.getPeaks()[index]
+ outer_edge, inner_edge, end_grad = fit_par.getEdgeParameters()
+ margin = fit_par.getMargin()
+ # get values around the expected center
all_values = ws.dataY(0)
- RIGHTLIMIT = len(all_values)
- values = all_values[max(centre-margin,0):min(centre+margin,len(all_values))]
-
- #identify if the edge is a sloping edge or descent edge
- descentMode = values[0] > values[-1]
- if descentMode:
- start = max(centre - outedge,0)
- end = min(centre + inedge, RIGHTLIMIT)
+ right_limit = len(all_values)
+ values = all_values[max(centre - margin, 0):min(centre + margin, len(all_values))]
+
+ # identify if the edge is a sloping edge or descent edge
+ descent_mode = values[0] > values[-1]
+ if descent_mode:
+ start = max(centre - outer_edge, 0)
+ end = min(centre + inner_edge, right_limit)
edgeMode = -1
else:
- start = max(centre - inedge,0)
- end = min(centre + outedge, RIGHTLIMIT)
+ start = max(centre - inner_edge, 0)
+ end = min(centre + outer_edge, right_limit)
edgeMode = 1
- Fit(InputWorkspace=ws,Function=fitEndErfcParams(centre,endGrad*edgeMode),StartX=str(start),EndX=str(end),Output=outputWs)
- return 1 # peakIndex (center) -> parameter B of EndERFC
+ Fit(InputWorkspace=ws, Function=fit_end_erfc_params(centre, end_grad * edgeMode), StartX=str(start), EndX=str(end),
+ Output=output_ws)
+ return 1 # peakIndex (center) -> parameter B of EndERFC
-def fitGaussian(fitPar, index, ws, outputWs):
- #find the peak position
- centre = fitPar.getPeaks()[index]
- margin = fitPar.getMargin()
+def fit_gaussian(fit_par, index, ws, output_ws):
+ # find the peak position
+ centre = fit_par.getPeaks()[index]
+ margin = fit_par.getMargin()
# get values around the expected center
all_values = ws.dataY(0)
- RIGHTLIMIT = len(all_values)
+ right_limit = len(all_values)
- min_index = max(centre-int(margin),0)
- max_index = min(centre+int(margin), RIGHTLIMIT)
+ min_index = max(centre - int(margin), 0)
+ max_index = min(centre + int(margin), right_limit)
values = all_values[min_index:max_index]
# find the peak position
- if fitPar.getAutomatic():
+ if fit_par.getAutomatic():
# find the parameters for fit dynamically
max_value = numpy.max(values)
min_value = numpy.min(values)
@@ -143,45 +141,47 @@ def fitGaussian(fitPar, index, ws, outputWs):
centre = numpy.argmax(values) + min_index
background = min_value
height = max_value - background
- width = len(numpy.where(values > height/2 + background))
+ width = len(numpy.where(values > height / 2 + background))
else:
# means that there are many values above the midle, so it is a trough
centre = numpy.argmin(values) + min_index
background = max_value
- height = min_value - max_value # negative value
- width = len(numpy.where(values < min_value + height/2))
+ height = min_value - max_value # negative value
+ width = len(numpy.where(values < min_value + height / 2))
start = max(centre - margin, 0)
- end = min(centre + margin, RIGHTLIMIT)
+ end = min(centre + margin, right_limit)
- fit_msg = 'name=LinearBackground,A0=%f;name=Gaussian,Height=%f,PeakCentre=%f,Sigma=%f'%(background, height, centre, width)
+ fit_msg = 'name=LinearBackground,A0=%f;name=Gaussian,Height=%f,PeakCentre=%f,Sigma=%f' % (
+ background, height, centre, width)
Fit(InputWorkspace=ws, Function=fit_msg,
- StartX = str(start), EndX=str(end), Output=outputWs)
+ StartX=str(start), EndX=str(end), Output=output_ws)
- peakIndex = 3
+ peak_index = 3
else:
# get the parameters from fitParams
background = 1000
- height, width = fitPar.getHeightAndWidth()
- start = max(centre-margin, 0)
- end = min(centre+margin, RIGHTLIMIT)
+ height, width = fit_par.getHeightAndWidth()
+ start = max(centre - margin, 0)
+ end = min(centre + margin, right_limit)
# fit the input data as a linear background + gaussian fit
# it was seen that the best result for static general fitParamters,
# is to divide the values in two fitting steps
- Fit(InputWorkspace=ws, Function='name=LinearBackground,A0=%f'%(background),
+ Fit(InputWorkspace=ws, Function='name=LinearBackground,A0=%f' % background,
StartX=str(start), EndX=str(end), Output='Z1')
- Fit(InputWorkspace='Z1_Workspace',Function='name=Gaussian,Height=%f,PeakCentre=%f,Sigma=%f' %(height, centre, width),
- WorkspaceIndex=2, StartX=str(start), EndX=str(end), Output=outputWs)
- CloneWorkspace(outputWs+'_Workspace',OutputWorkspace='gauss_'+str(index))
- peakIndex = 1
+ Fit(InputWorkspace='Z1_Workspace',
+ Function='name=Gaussian,Height=%f,PeakCentre=%f,Sigma=%f' % (height, centre, width),
+ WorkspaceIndex=2, StartX=str(start), EndX=str(end), Output=output_ws)
+ CloneWorkspace(output_ws + '_Workspace', OutputWorkspace='gauss_' + str(index))
+ peak_index = 1
- return peakIndex
+ return peak_index
-def getPoints ( IntegratedWorkspace, funcForms, fitParams, whichTube, showPlot=False ):
+def getPoints(integrated_ws, func_forms, fit_params, which_tube, show_plot=False):
"""
Get the centres of N slits or edges for calibration
@@ -191,70 +191,69 @@ def getPoints ( IntegratedWorkspace, funcForms, fitParams, whichTube, showPlot=F
.. note::
This N slit method is suited for WISH or the five sharp peaks of MERLIN .
- :param IntegratedWorkspace: Workspace of integrated data
- :param funcForms: array of function form 1=slit/bar, 2=edge
- :param fitParams: a TubeCalibFitParams object contain the fit parameters
- :param whichTube: a list of workspace indices for one tube (define a single tube)
- :param showPlot: show plot for this tube
+ :param integrated_ws: Workspace of integrated data
+ :param func_forms: array of function form 1=slit/bar, 2=edge
+ :param fit_params: a TubeCalibFitParams object contain the fit parameters
+ :param which_tube: a list of workspace indices for one tube (define a single tube)
+ :param show_plot: show plot for this tube
:rtype: array of the slit/edge positions (-1.0 indicates failed to find position)
"""
# Create input workspace for fitting
- ## get all the counts for the integrated workspace inside the tube
- countsY = numpy.array([IntegratedWorkspace.dataY(i)[0] for i in whichTube])
- if len(countsY) == 0:
+ # get all the counts for the integrated workspace inside the tube
+ counts_y = numpy.array([integrated_ws.dataY(i)[0] for i in which_tube])
+ if len(counts_y) == 0:
return
- getPointsWs = CreateWorkspace(range(len(countsY)),countsY,OutputWorkspace='TubePlot')
- calibPointWs = 'CalibPoint'
+ get_points_ws = CreateWorkspace(range(len(counts_y)), counts_y, OutputWorkspace='TubePlot')
+ calib_points_ws = 'CalibPoint'
results = []
fitt_y_values = []
fitt_x_values = []
# Loop over the points
- for i in range(len(funcForms)):
- if funcForms[i] == 2:
- # find the edge position
- peakIndex = fitEdges(fitParams, i, getPointsWs, calibPointWs)
+ for i in range(len(func_forms)):
+ if func_forms[i] == 2:
+ # find the edge position
+ peak_index = fit_edges(fit_params, i, get_points_ws, calib_points_ws)
else:
- peakIndex = fitGaussian(fitParams, i, getPointsWs, calibPointWs)
+ peak_index = fit_gaussian(fit_params, i, get_points_ws, calib_points_ws)
- # get the peak centre
- peakCentre = mtd[calibPointWs + '_Parameters'].row(peakIndex).items()[1][1]
- results.append(peakCentre)
+ peak_centre = mtd[calib_points_ws + '_Parameters'].row(peak_index).items()[1][1]
+ results.append(peak_centre)
- if showPlot:
- ws = mtd[calibPointWs + '_Workspace']
+ if show_plot:
+ ws = mtd[calib_points_ws + '_Workspace']
fitt_y_values.append(copy.copy(ws.dataY(1)))
fitt_x_values.append(copy.copy(ws.dataX(1)))
- if showPlot:
+ if show_plot:
CreateWorkspace(OutputWorkspace='FittedData',
DataX=numpy.hstack(fitt_x_values),
DataY=numpy.hstack(fitt_y_values))
return results
-def getIdealTubeFromNSlits ( IntegratedWorkspace, slits ):
+def get_ideal_tube_from_n_slits(integrated_workspace, slits):
"""
Given N slits for calibration on an ideal tube
convert to Y values to form a ideal tube for correctTubeToIdealTube()
- @param IntegratedWorkspace: Workspace of integrated data
- @param eP: positions of slits for ideal tube (in pixels)
+ @param integrated_workspace: Workspace of integrated data
+ @param slits: positions of slits for ideal tube (in pixels)
Return Value: Ideal tube in Y-coords for use by correctTubeToIdealTube()
"""
ideal = []
for i in range(len(slits)):
- ideal.append( get_ypos( IntegratedWorkspace, slits[i] )) # Use Pascal Manuel's Y conversion.
+ ideal.append(get_ypos(integrated_workspace, slits[i])) # Use Pascal Manuel's Y conversion.
return ideal
-def correctTube( AP, BP, CP, nDets ):
+def correct_tube(AP, BP, CP, nDets):
"""
Corrects position errors in a tube in the same manner as is done for MERLIN
according to an algorithm used by Rob Bewley in his MATLAB code.
@@ -267,35 +266,36 @@ def correctTube( AP, BP, CP, nDets ):
Return Value: Array of corrected Xs (in pixels)
"""
- AO = AP/(nDets - AP)
- BO = (nDets - BP)/BP
+ AO = AP / (nDets - AP)
+ BO = (nDets - BP) / BP
# First correct centre point for offsets
- CPN = CP - (AO*(nDets - CP)) + BO*CP
+ CPN = CP - (AO * (nDets - CP)) + BO * CP
x = []
for i in range(nDets):
- xi = i+1.0
- x.append( xi -((nDets-xi)*AO) + (xi*BO)) #this is x corrected for offsets
+ xi = i + 1.0
+ x.append(xi - ((nDets - xi) * AO) + (xi * BO)) # this is x corrected for offsets
# Now calculate the gain error
- GainError = ( (nDets+1)/2.0 - CPN) / (CPN*(nDets-CPN))
- xBinNew = []
+ gain_error = ((nDets + 1) / 2.0 - CPN) / (CPN * (nDets - CPN))
+ x_bin_new = []
for i in range(nDets):
xo = x[i]
- xBinNew.append( xo + ( xo*(nDets-xo)*GainError )) #Final bin position values corrected for offsets and gain
+ # Final bin position values corrected for offsets and gain
+ x_bin_new.append(xo + (xo * (nDets - xo) * gain_error))
- return xBinNew
+ return x_bin_new
-def correctTubeToIdealTube( tubePoints, idealTubePoints, nDets, TestMode=False, polinFit=2 ):
+def correct_tube_to_ideal_tube(tube_points, ideal_tube_points, n_detectors, test_mode=False, polin_fit=2):
"""
Corrects position errors in a tube given an array of points and their ideal positions.
- :param tubePoints: Array of Slit Points along tube to be fitted (in pixels)
- :param idealTubePoints: The corresponding points in an ideal tube (Y-coords advised)
- :param nDets: Number of pixel detectors in tube
- :param Testmode: If true, detectors at the position of a slit will be moved out of the way
+ :param tube_points: Array of Slit Points along tube to be fitted (in pixels)
+ :param ideal_tube_points: The corresponding points in an ideal tube (Y-coords advised)
+ :param n_detectors: Number of pixel detectors in tube
+ :param test_mode: If true, detectors at the position of a slit will be moved out of the way
to show the reckoned slit positions when the instrument is displayed.
- :param polinFit: Order of the polinomial to fit for the ideal positions
+ :param polin_fit: Order of the polynomial to fit for the ideal positions
Return Value: Array of corrected Xs (in same units as ideal tube points)
@@ -303,121 +303,125 @@ def correctTubeToIdealTube( tubePoints, idealTubePoints, nDets, TestMode=False,
"""
# Check the arguments
- if len(tubePoints) != len(idealTubePoints) :
- print("Number of points in tube", len(tubePoints),"must equal number of points in ideal tube", len(idealTubePoints))
- return xResult
+ if len(tube_points) != len(ideal_tube_points):
+ print("Number of points in tube {0} must equal number of points in ideal tube {1}".
+ format(len(tube_points), len(ideal_tube_points)))
+ return x_result
# Filter out rogue slit points
- usedTubePoints = []
- usedIdealTubePoints = []
- missedTubePoints = [] # Used for diagnostic print only
- for i in range(len(tubePoints)):
- if tubePoints[i] > 0.0 and tubePoints[i] < nDets:
- usedTubePoints.append( tubePoints[i] )
- usedIdealTubePoints.append ( idealTubePoints[i] )
+ used_tube_points = []
+ used_ideal_tube_points = []
+ missed_tube_points = [] # Used for diagnostic print only
+ for i in range(len(tube_points)):
+ if 0.0 < tube_points[i] < n_detectors:
+ used_tube_points.append(tube_points[i])
+ used_ideal_tube_points.append(ideal_tube_points[i])
else:
- missedTubePoints.append(i+1)
+ missed_tube_points.append(i + 1)
# State number of rogue slit points, if any
- if len(tubePoints) != len(usedTubePoints):
- print("Only",len(usedTubePoints),"out of",len(tubePoints)," slit points used. Missed",missedTubePoints)
+ if len(tube_points) != len(used_tube_points):
+ print("Only {0} out of {1} slit points used. Missed {2}".format(len(used_tube_points), len(tube_points),
+ missed_tube_points))
# Check number of usable points
- if len(usedTubePoints) < 3:
- print("Too few usable points in tube",len(usedTubePoints))
+ if len(used_tube_points) < 3:
+ print("Too few usable points in tube {0}".format(len(used_tube_points)))
return []
# Fit quadratic to ideal tube points
- CreateWorkspace(dataX=usedTubePoints,dataY=usedIdealTubePoints, OutputWorkspace="PolyFittingWorkspace")
+ CreateWorkspace(dataX=used_tube_points, dataY=used_ideal_tube_points, OutputWorkspace="PolyFittingWorkspace")
try:
- Fit(InputWorkspace="PolyFittingWorkspace",Function='name=Polynomial,n=%d'%(polinFit),StartX=str(0.0),EndX=str(nDets),Output="QF")
+ Fit(InputWorkspace="PolyFittingWorkspace", Function='name=Polynomial,n=%d' % polin_fit, StartX=str(0.0),
+ EndX=str(n_detectors), Output="QF")
except:
print("Fit failed")
return []
- paramQF = mtd['QF_Parameters']
+ param_q_f = mtd['QF_Parameters']
- # get the coeficients, get the Value from every row, and exclude the last one because it is the error
+ # get the coefficients, get the Value from every row, and exclude the last one because it is the error
# rowErr is the last one, it could be used to check accuracy of fit
- c = [r['Value'] for r in paramQF][:-1]
+ c = [r['Value'] for r in param_q_f][:-1]
# Modify the output array by the fitted quadratic
- xResult = numpy.polynomial.polynomial.polyval(range(nDets),c)
+ x_result = numpy.polynomial.polynomial.polyval(range(n_detectors), c)
# In test mode, shove the pixels that are closest to the reckoned peaks
# to the position of the first detector so that the resulting gaps can be seen.
- if TestMode :
+ if test_mode:
print("TestMode code")
- for i in range( len(usedTubePoints) ):
- xResult[ int(usedTubePoints[i]) ] = xResult[0]
+ for i in range(len(used_tube_points)):
+ x_result[int(used_tube_points[i])] = x_result[0]
- return xResult
+ return x_result
-def getCalibratedPixelPositions( ws, tubePts, idealTubePts, whichTube, peakTestMode=False, polinFit=2 ):
+def getCalibratedPixelPositions(ws, tube_positions, ideal_tube_positions, which_tube, peak_test_mode=False,
+ polin_fit=2):
"""
Get the calibrated detector positions for one tube
The tube is specified by a list of workspace indices of its spectra
Calibration is assumed to be done parallel to the Y-axis
:param ws: Workspace with tubes to be calibrated - may be integrated or raw
- :param tubePts: Array of calibration positions (in pixels)
- :param idealTubePts: Where these calibration positions should be (in Y coords)
- :param whichtube: a list of workspace indices for the tube
- :param PeakTestMode: true if shoving detectors that are reckoned to be at peak away (for test purposes)
- :param polinFit: Order of the polinominal to fit for the ideal positions
+ :param tube_positions: Array of calibration positions (in pixels)
+ :param ideal_tube_positions: Where these calibration positions should be (in Y coords)
+ :param which_tube: a list of workspace indices for the tube
+ :param peak_test_mode: true if shoving detectors that are reckoned to be at peak away (for test purposes)
+ :param polin_fit: Order of the polynomial to fit for the ideal positions
Return Array of pixel detector IDs and array of their calibrated positions
"""
# Arrays to be returned
- detIDs = []
- detPositions = []
- #Get position of first and last pixel of tube
- nDets = len(whichTube)
- if nDets < 1:
- return detIDs, detPositions
+ det_IDs = []
+ det_positions = []
+ # Get position of first and last pixel of tube
+ n_dets = len(which_tube)
+ if n_dets < 1:
+ return det_IDs, det_positions
# Correct positions of detectors in tube by quadratic fit
- pixels = correctTubeToIdealTube ( tubePts, idealTubePts, nDets, TestMode=peakTestMode, polinFit=polinFit )
- if len(pixels) != nDets:
+ pixels = correct_tube_to_ideal_tube(tube_positions, ideal_tube_positions, n_dets, test_mode=peak_test_mode, polin_fit=polin_fit)
+ if len(pixels) != n_dets:
print("Tube correction failed.")
- return detIDs, detPositions
- baseInstrument = ws.getInstrument().getBaseInstrument()
+ return det_IDs, det_positions
+ base_instrument = ws.getInstrument().getBaseInstrument()
# Get tube unit vector
# get the detector from the baseInstrument, in order to get the positions
# before any calibration being loaded.
- det0 = baseInstrument.getDetector(ws.getDetector( whichTube[0]).getID())
- detN = baseInstrument.getDetector(ws.getDetector (whichTube[-1]).getID())
- d0pos,dNpos = det0.getPos(),detN.getPos()
- ## identical to norm of vector: |dNpos - d0pos|
+ det0 = base_instrument.getDetector(ws.getDetector(which_tube[0]).getID())
+ detN = base_instrument.getDetector(ws.getDetector(which_tube[-1]).getID())
+ d0pos, dNpos = det0.getPos(), detN.getPos()
+ # identical to norm of vector: |dNpos - d0pos|
tubeLength = det0.getDistance(detN)
- if tubeLength <= 0.0:
+ if tubeLength <= 0.0:
print("Zero length tube cannot be calibrated, calibration failed.")
- return detIDs, detPositions
- #unfortunatelly, the operation '/' is not defined in V3D object, so
- #I have to use the multiplication.
+ return det_IDs, det_positions
+ # unfortunately, the operation '/' is not defined in V3D object, so
+ # I have to use the multiplication.
# unit_vectors are defined as u = (v2-v1)/|v2-v1| = (dn-d0)/length
- unit_vector = (dNpos-d0pos) * (1.0/tubeLength)
+ unit_vector = (dNpos - d0pos) * (1.0 / tubeLength)
# Get Centre (really want to get if from IDF to allow calibration a multiple number of times)
- center = (dNpos+d0pos)*0.5 #(1.0/2)
+ center = (dNpos + d0pos) * 0.5 # (1.0/2)
# Move the pixel detectors (might not work for sloping tubes)
- for i in range(nDets):
- deti = ws.getDetector( whichTube[i])
- pNew = pixels[i]
+ for i in range(n_dets):
+ deti = ws.getDetector(which_tube[i])
+ p_new = pixels[i]
# again, the opeartion float * v3d is not defined, but v3d * float is,
# so, I wrote the new pos as center + unit_vector * (float)
- newPos = center + unit_vector * pNew
+ new_pos = center + unit_vector * p_new
- detIDs.append( deti.getID() )
- detPositions.append( newPos )
+ det_IDs.append(deti.getID())
+ det_positions.append(new_pos)
- return detIDs, detPositions
+ return det_IDs, det_positions
-def readPeakFile(file_name):
+def read_peak_file(file_name):
"""Load the file calibration
It returns a list of tuples, where the first value is the detector identification
@@ -430,37 +434,37 @@ def readPeakFile(file_name):
"""
loaded_file = []
- #split the entries to the main values:
+ # split the entries to the main values:
# For example:
# MERLIN/door1/tube_1_1 [34.199347724575574, 525.5864438725401, 1001.7456248836971]
# Will be splited as:
# ['MERLIN/door1/tube_1_1', '', '34.199347724575574', '', '525.5864438725401', '', '1001.7456248836971', '', '', '']
pattern = re.compile('[\[\],\s\r]')
- saveDirectory = config['defaultsave.directory']
- pfile = os.path.join(saveDirectory, file_name)
- for line in open(pfile,'r'):
- #check if the entry is a comment line
+ save_directory = config['defaultsave.directory']
+ pfile = os.path.join(save_directory, file_name)
+ for line in open(pfile, 'r'):
+ # check if the entry is a comment line
if line.startswith('#'):
continue
- #split all values
- line_vals = re.split(pattern,line)
+ # split all values
+ line_vals = re.split(pattern, line)
id_ = line_vals[0]
if id_ == '':
continue
try:
- f_values = [float(v) for v in line_vals[1:] if v!='']
+ f_values = [float(v) for v in line_vals[1:] if v != '']
except ValueError:
continue
- loaded_file.append((id_,f_values))
+ loaded_file.append((id_, f_values))
return loaded_file
### THESE FUNCTIONS NEXT SHOULD BE THE ONLY FUNCTIONS THE USER CALLS FROM THIS FILE
-def getCalibration( ws, tubeSet, calibTable, fitPar, iTube, peaksTable,
- overridePeaks=dict(), excludeShortTubes=0.0, plotTube=[],
- rangeList = None, polinFit=2, peaksTestMode=False):
+def getCalibration(ws, tubeSet, calibTable, fitPar, iTube, peaksTable,
+ overridePeaks=dict(), excludeShortTubes=0.0, plotTube=[],
+ range_list=None, polinFit=2, peaksTestMode=False):
"""
Get the results the calibration and put them in the calibration table provided.
@@ -472,40 +476,41 @@ def getCalibration( ws, tubeSet, calibTable, fitPar, iTube, peaksTable,
:param iTube: The :class:`~ideal_tube.IdealTube` which contains the positions in metres of the shadows of the slits,
bars or edges used for calibration.
:param peaksTable: Peaks table into wich the peaks positions will be put
- :param overridePeak: dictionary with tube indexes keys and an array of peaks in pixels to override those that would be
+ :param overridePeaks: dictionary with tube indexes keys and an array of peaks in pixels to override those that would be
fitted for one tube
- :param exludeShortTubes: Exlude tubes shorter than specified length from calibration
+ :param excludeShortTubes: Exlude tubes shorter than specified length from calibration
:param plotTube: List of tube indexes that will be ploted
- :param rangelist: list of the tube indexes that will be calibrated. Default None, means all the tubes in tubeSet
- :param polinFit: Order of the polinomial to fit against the known positions. Acceptable: 2, 3
- :param peakTestMode: true if shoving detectors that are reckoned to be at peak away (for test purposes)
+ :param range_list: list of the tube indexes that will be calibrated. Default None, means all the tubes in tubeSet
+ :param polinFit: Order of the polynomial to fit against the known positions. Acceptable: 2, 3
+ :param peaksTestMode: true if shoving detectors that are reckoned to be at peak away (for test purposes)
This is the main method called from :func:`~tube.calibrate` to perform the calibration.
"""
- nTubes = tubeSet.getNumTubes()
- print("Number of tubes =",nTubes)
+ n_tubes = tubeSet.getNumTubes()
+ print("Number of tubes =", n_tubes)
- if rangeList is None:
- rangeList = range(nTubes)
+ if range_list is None:
+ range_list = range(n_tubes)
all_skipped = set()
- for i in rangeList:
+ for i in range_list:
# Deal with (i+1)st tube specified
wht, skipped = tubeSet.getTube(i)
all_skipped.update(skipped)
- print("Calibrating tube", i+1,"of",nTubes, tubeSet.getTubeName(i))
- if len(wht) < 1 :
- print("Unable to get any workspace indices (spectra) for this tube. Tube",tubeSet.getTubeName(i),"not calibrated.")
- #skip this tube
+ print("Calibrating tube", i + 1, "of", n_tubes, tubeSet.getTubeName(i))
+ if len(wht) < 1:
+ print("Unable to get any workspace indices (spectra) for this tube. Tube", tubeSet.getTubeName(i),
+ "not calibrated.")
+ # skip this tube
continue
# Calibribate the tube, if possible
if tubeSet.getTubeLength(i) <= excludeShortTubes:
- #skip this tube
+ # skip this tube
continue
##############################
@@ -514,35 +519,37 @@ def getCalibration( ws, tubeSet, calibTable, fitPar, iTube, peaksTable,
# if this tube is to be override, get the peaks positions for this tube.
if i in overridePeaks:
- actualTube = overridePeaks[i]
+ actual_tube = overridePeaks[i]
else:
- #find the peaks positions
- plotThisTube = i in plotTube
- actualTube = getPoints(ws, iTube.getFunctionalForms(), fitPar, wht, showPlot = plotThisTube)
- if plotThisTube:
- RenameWorkspace('FittedData',OutputWorkspace='FittedTube%d'%(i))
- RenameWorkspace('TubePlot', OutputWorkspace='TubePlot%d'%(i))
+ # find the peaks positions
+ plot_this_tube = i in plotTube
+ actual_tube = getPoints(ws, iTube.getFunctionalForms(), fitPar, wht, show_plot=plot_this_tube)
+ if plot_this_tube:
+ RenameWorkspace('FittedData', OutputWorkspace='FittedTube%d' % (i))
+ RenameWorkspace('TubePlot', OutputWorkspace='TubePlot%d' % (i))
# Set the peak positions at the peakTable
- peaksTable.addRow([tubeSet.getTubeName(i)] + list(actualTube))
+ peaksTable.addRow([tubeSet.getTubeName(i)] + list(actual_tube))
##########################################
# Define the correct position of detectors
##########################################
- detIDList, detPosList = getCalibratedPixelPositions( ws, actualTube, iTube.getArray(), wht, peaksTestMode, polinFit)
- #save the detector positions to calibTable
- if len(detIDList) == len(wht): # We have corrected positions
+ det_id_list, det_position_list = getCalibratedPixelPositions(ws, actual_tube, iTube.getArray(), wht,
+ peaksTestMode, polinFit)
+ # save the detector positions to calibTable
+ if len(det_id_list) == len(wht): # We have corrected positions
for j in range(len(wht)):
- nextRow = {'Detector ID': detIDList[j], 'Detector Position': detPosList[j] }
- calibTable.addRow ( nextRow )
+ next_row = {'Detector ID': det_id_list[j], 'Detector Position': det_position_list[j]}
+ calibTable.addRow(next_row)
if len(all_skipped) > 0:
- print("%i histogram(s) were excluded from the calibration since they did not have an assigned detector." % len(all_skipped))
+ print("%i histogram(s) were excluded from the calibration since they did not have an assigned detector." % len(
+ all_skipped))
# Delete temporary workspaces used in the calibration
- for ws_name in ('TubePlot','CalibPoint_NormalisedCovarianceMatrix',
- 'CalibPoint_NormalisedCovarianceMatrix','CalibPoint_NormalisedCovarianceMatrix',
+ for ws_name in ('TubePlot', 'CalibPoint_NormalisedCovarianceMatrix',
+ 'CalibPoint_NormalisedCovarianceMatrix', 'CalibPoint_NormalisedCovarianceMatrix',
'CalibPoint_Parameters', 'CalibPoint_Workspace', 'PolyFittingWorkspace',
'QF_NormalisedCovarianceMatrix', 'QF_Parameters', 'QF_Workspace',
'Z1_Workspace', 'Z1_Parameters', 'Z1_NormalisedCovarianceMatrix'):
@@ -552,47 +559,47 @@ def getCalibration( ws, tubeSet, calibTable, fitPar, iTube, peaksTable,
pass
-def getCalibrationFromPeakFile ( ws, calibTable, iTube, PeakFile ):
+def getCalibrationFromPeakFile(ws, calibTable, iTube, PeakFile):
"""
Get the results the calibration and put them in the calibration table provided.
@param ws: Integrated Workspace with tubes to be calibrated
@param calibTable: Calibration table into which the calibration results are placed
@param iTube: The ideal tube
- @param PeakFile: File of peaks for calibtation
+ @param PeakFile: File of peaks for calibration
"""
# Get Ideal Tube
- idealTube = iTube.getArray()
+ ideal_tube = iTube.getArray()
# Read Peak File
- PeakArray = readPeakFile( PeakFile )
- nTubes = len(PeakArray)
- print("Number of tubes read from file =",nTubes)
+ peak_array = read_peak_file(PeakFile)
+ n_tubes = len(peak_array)
+ print("Number of tubes read from file =", n_tubes)
- for i in range(nTubes):
+ for i in range(n_tubes):
# Deal with (i+1)st tube got from file
- TubeName = PeakArray[i][0] # e.g. 'MERLIN/door3/tube_3_1'
+ tube_name = peak_array[i][0] # e.g. 'MERLIN/door3/tube_3_1'
tube = TubeSpec(ws)
- tube.setTubeSpecByString(TubeName)
- actualTube = PeakArray[i][1] # e.g. [2.0, 512.5, 1022.0]
+ tube.setTubeSpecByString(tube_name)
+ actual_tube = peak_array[i][1] # e.g. [2.0, 512.5, 1022.0]
wht, _ = tube.getTube(0)
- print("Calibrating tube", i+1 ,"of", nTubes, TubeName)
- if len(wht) < 1 :
+ print("Calibrating tube", i + 1, "of", n_tubes, tube_name)
+ if len(wht) < 1:
print("Unable to get any workspace indices for this tube. Calibration abandoned.")
return
- detIDList, detPosList = getCalibratedPixelPositions( ws, actualTube, idealTube, wht)
+ det_id_list, det_pos_list = getCalibratedPixelPositions(ws, actual_tube, ideal_tube, wht)
- if len(detIDList) == len(wht): # We have corrected positions
+ if len(det_id_list) == len(wht): # We have corrected positions
for j in range(len(wht)):
- nextRow = {'Detector ID': detIDList[j], 'Detector Position': detPosList[j] }
- calibTable.addRow ( nextRow )
+ next_row = {'Detector ID': det_id_list[j], 'Detector Position': det_pos_list[j]}
+ calibTable.addRow(next_row)
- if nTubes == 0:
+ if n_tubes == 0:
return
# Delete temporary workspaces for getting new detector positions
@@ -603,7 +610,7 @@ def getCalibrationFromPeakFile ( ws, calibTable, iTube, PeakFile ):
## implement this function
-def constructIdealTubeFromRealTube( ws, tube, fitPar, funcForm ):
+def constructIdealTubeFromRealTube(ws, tube, fitPar, funcForm):
"""
Construct an ideal tube from an actual tube (assumed ideal)
@@ -614,31 +621,31 @@ def constructIdealTubeFromRealTube( ws, tube, fitPar, funcForm ):
:rtype: IdealTube
"""
- # Get workspace indices
- idealTube = IdealTube()
+ # Get workspace indices
+ ideal_tube = IdealTube()
- nTubes = tube.getNumTubes()
- if nTubes < 1:
+ n_tubes = tube.getNumTubes()
+ if n_tubes < 1:
raise RuntimeError("Invalid tube specification received by constructIdealTubeFromRealTube")
- elif nTubes > 1:
- print("Specification has several tubes. The ideal tube will be based on the first tube",tube.getTubeName(0))
+ elif n_tubes > 1:
+ print("Specification has several tubes. The ideal tube will be based on the first tube", tube.getTubeName(0))
wht, _ = tube.getTube(0)
- # Check tube
- if len(wht) < 1 :
+ # Check tube
+ if len(wht) < 1:
raise RuntimeError("Unable to get any workspace indices for this tube. Cannot use as ideal tube.")
- # Get actual tube on which ideal tube is based
- actualTube = getPoints ( ws, funcForm, fitPar, wht)
- print("Actual tube that ideal tube is to be based upon",actualTube)
+ # Get actual tube on which ideal tube is based
+ actual_tube = getPoints(ws, funcForm, fitPar, wht)
+ print("Actual tube that ideal tube is to be based upon", actual_tube)
- # Get ideal tube based on this actual tube
+ # Get ideal tube based on this actual tube
try:
- idealTube.setArray(actualTube)
+ ideal_tube.setArray(actual_tube)
except:
- msg = "Attempted to create ideal tube based on actual tube" + str(actualTube)
+ msg = "Attempted to create ideal tube based on actual tube" + str(actual_tube)
msg += "Unable to create ideal tube."
msg += "Please choose another tube for constructIdealTubeFromRealTube()."
raise RuntimeError(msg)
- return idealTube
+ return ideal_tube
diff --git a/scripts/DGSPlanner/DGSPlannerGUI.py b/scripts/DGSPlanner/DGSPlannerGUI.py
index f5d1ea86b22ecc547f306fc744f61f83a2c1516b..ebba33f3d4df2c1164c3985f4f9171f5d4fe4e4c 100644
--- a/scripts/DGSPlanner/DGSPlannerGUI.py
+++ b/scripts/DGSPlanner/DGSPlannerGUI.py
@@ -1,4 +1,4 @@
-#pylint: disable=invalid-name,relative-import
+# pylint: disable=invalid-name,relative-import
from __future__ import (absolute_import, division, print_function)
from . import InstrumentSetupWidget
from . import ClassicUBInputWidget
@@ -24,68 +24,69 @@ def float2Input(x):
else:
return None
+
# pylint: disable=too-many-instance-attributes
class DGSPlannerGUI(QtGui.QWidget):
- def __init__(self,ol=None,parent=None):
+ def __init__(self, ol=None, parent=None):
# pylint: disable=unused-argument,super-on-old-class
- super(DGSPlannerGUI,self).__init__(parent)
- #OrientedLattice
+ super(DGSPlannerGUI, self).__init__(parent)
+ # OrientedLattice
if ValidateOL(ol):
- self.ol=ol
+ self.ol = ol
else:
- self.ol=mantid.geometry.OrientedLattice()
- self.masterDict=dict() #holds info about instrument and ranges
- self.updatedInstrument=False
- self.updatedOL=False
- self.wg=None #workspace group
- self.instrumentWidget=InstrumentSetupWidget.InstrumentSetupWidget(self)
+ self.ol = mantid.geometry.OrientedLattice()
+ self.masterDict = dict() # holds info about instrument and ranges
+ self.updatedInstrument = False
+ self.updatedOL = False
+ self.wg = None # workspace group
+ self.instrumentWidget = InstrumentSetupWidget.InstrumentSetupWidget(self)
self.setLayout(QtGui.QHBoxLayout())
- controlLayout=QtGui.QVBoxLayout()
+ controlLayout = QtGui.QVBoxLayout()
controlLayout.addWidget(self.instrumentWidget)
- self.ublayout=QtGui.QHBoxLayout()
- self.classic=ClassicUBInputWidget.ClassicUBInputWidget(self.ol)
- self.ublayout.addWidget(self.classic,alignment=QtCore.Qt.AlignTop,stretch=1)
- self.matrix=MatrixUBInputWidget.MatrixUBInputWidget(self.ol)
- self.ublayout.addWidget(self.matrix,alignment=QtCore.Qt.AlignTop,stretch=1)
+ self.ublayout = QtGui.QHBoxLayout()
+ self.classic = ClassicUBInputWidget.ClassicUBInputWidget(self.ol)
+ self.ublayout.addWidget(self.classic, alignment=QtCore.Qt.AlignTop, stretch=1)
+ self.matrix = MatrixUBInputWidget.MatrixUBInputWidget(self.ol)
+ self.ublayout.addWidget(self.matrix, alignment=QtCore.Qt.AlignTop, stretch=1)
controlLayout.addLayout(self.ublayout)
- self.dimensionWidget=DimensionSelectorWidget.DimensionSelectorWidget(self)
+ self.dimensionWidget = DimensionSelectorWidget.DimensionSelectorWidget(self)
controlLayout.addWidget(self.dimensionWidget)
- plotControlLayout=QtGui.QGridLayout()
- self.plotButton=QtGui.QPushButton("Plot",self)
- self.oplotButton=QtGui.QPushButton("Overplot",self)
- self.helpButton=QtGui.QPushButton("?",self)
- self.colorLabel=QtGui.QLabel('Color by angle',self)
- self.colorButton=QtGui.QCheckBox(self)
+ plotControlLayout = QtGui.QGridLayout()
+ self.plotButton = QtGui.QPushButton("Plot", self)
+ self.oplotButton = QtGui.QPushButton("Overplot", self)
+ self.helpButton = QtGui.QPushButton("?", self)
+ self.colorLabel = QtGui.QLabel('Color by angle', self)
+ self.colorButton = QtGui.QCheckBox(self)
self.colorButton.toggle()
- self.aspectLabel=QtGui.QLabel('Aspect ratio 1:1',self)
- self.aspectButton=QtGui.QCheckBox(self)
- self.saveButton=QtGui.QPushButton("Save Figure",self)
- plotControlLayout.addWidget(self.plotButton,0,0)
- plotControlLayout.addWidget(self.oplotButton,0,1)
- plotControlLayout.addWidget(self.colorLabel,0,2,QtCore.Qt.AlignRight)
- plotControlLayout.addWidget(self.colorButton,0,3)
- plotControlLayout.addWidget(self.aspectLabel,0,4,QtCore.Qt.AlignRight)
- plotControlLayout.addWidget(self.aspectButton,0,5)
- plotControlLayout.addWidget(self.helpButton,0,6)
- plotControlLayout.addWidget(self.saveButton,0,7)
+ self.aspectLabel = QtGui.QLabel('Aspect ratio 1:1', self)
+ self.aspectButton = QtGui.QCheckBox(self)
+ self.saveButton = QtGui.QPushButton("Save Figure", self)
+ plotControlLayout.addWidget(self.plotButton, 0, 0)
+ plotControlLayout.addWidget(self.oplotButton, 0, 1)
+ plotControlLayout.addWidget(self.colorLabel, 0, 2, QtCore.Qt.AlignRight)
+ plotControlLayout.addWidget(self.colorButton, 0, 3)
+ plotControlLayout.addWidget(self.aspectLabel, 0, 4, QtCore.Qt.AlignRight)
+ plotControlLayout.addWidget(self.aspectButton, 0, 5)
+ plotControlLayout.addWidget(self.helpButton, 0, 6)
+ plotControlLayout.addWidget(self.saveButton, 0, 7)
controlLayout.addLayout(plotControlLayout)
self.layout().addLayout(controlLayout)
- #figure
- self.figure=Figure()
+ # figure
+ self.figure = Figure()
self.figure.patch.set_facecolor('white')
- self.canvas=FigureCanvas(self.figure)
+ self.canvas = FigureCanvas(self.figure)
self.grid_helper = GridHelperCurveLinear((self.tr, self.inv_tr))
self.trajfig = Subplot(self.figure, 1, 1, 1, grid_helper=self.grid_helper)
self.trajfig.hold(True)
self.figure.add_subplot(self.trajfig)
self.layout().addWidget(self.canvas)
- self.needToClear=False
- self.saveDir=''
+ self.needToClear = False
+ self.saveDir = ''
- #connections
+ # connections
self.matrix.UBmodel.changed.connect(self.updateUB)
self.matrix.UBmodel.changed.connect(self.classic.updateOL)
self.classic.changed.connect(self.matrix.UBmodel.updateOL)
@@ -96,37 +97,37 @@ class DGSPlannerGUI(QtGui.QWidget):
self.oplotButton.clicked.connect(self.updateFigure)
self.helpButton.clicked.connect(self.help)
self.saveButton.clicked.connect(self.save)
- #force an update of values
+ # force an update of values
self.instrumentWidget.updateAll()
self.dimensionWidget.updateChanges()
- #help
+ # help
self.assistantProcess = QtCore.QProcess(self)
# pylint: disable=protected-access
- self.collectionFile=os.path.join(mantid._bindir,'../docs/qthelp/MantidProject.qhc')
+ self.collectionFile = os.path.join(mantid._bindir, '../docs/qthelp/MantidProject.qhc')
version = ".".join(mantid.__version__.split(".")[:2])
- self.qtUrl='qthelp://org.sphinx.mantidproject.'+version+'/doc/interfaces/DGSPlanner.html'
- self.externalUrl='http://docs.mantidproject.org/nightly/interfaces/DGSPlanner.html'
- #control for cancel button
- self.iterations=0
- self.progress_canceled=False
+ self.qtUrl = 'qthelp://org.sphinx.mantidproject.' + version + '/doc/interfaces/DGSPlanner.html'
+ self.externalUrl = 'http://docs.mantidproject.org/nightly/interfaces/DGSPlanner.html'
+ # control for cancel button
+ self.iterations = 0
+ self.progress_canceled = False
- #register startup
- mantid.UsageService.registerFeatureUsage("Interface","DGSPlanner",False)
+ # register startup
+ mantid.UsageService.registerFeatureUsage("Interface", "DGSPlanner", False)
@QtCore.pyqtSlot(mantid.geometry.OrientedLattice)
- def updateUB(self,ol):
- self.ol=ol
- self.updatedOL=True
+ def updateUB(self, ol):
+ self.ol = ol
+ self.updatedOL = True
self.trajfig.clear()
@QtCore.pyqtSlot(dict)
- def updateParams(self,d):
+ def updateParams(self, d):
if self.sender() is self.instrumentWidget:
- self.updatedInstrument=True
- if 'dimBasis' in d and 'dimBasis' in self.masterDict and d['dimBasis']!=self.masterDict['dimBasis']:
- self.needToClear=True
- if 'dimIndex' in d and 'dimIndex' in self.masterDict and d['dimIndex']!=self.masterDict['dimIndex']:
- self.needToClear=True
+ self.updatedInstrument = True
+ if 'dimBasis' in d and 'dimBasis' in self.masterDict and d['dimBasis'] != self.masterDict['dimBasis']:
+ self.needToClear = True
+ if 'dimIndex' in d and 'dimIndex' in self.masterDict and d['dimIndex'] != self.masterDict['dimIndex']:
+ self.needToClear = True
self.masterDict.update(copy.deepcopy(d))
def help(self):
@@ -138,7 +139,7 @@ class DGSPlannerGUI(QtGui.QWidget):
self.assistantProcess.waitForFinished()
helpapp = QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.BinariesPath) + QtCore.QDir.separator()
helpapp += 'assistant'
- args = ['-enableRemoteControl', '-collectionFile',self.collectionFile,'-showUrl',self.qtUrl]
+ args = ['-enableRemoteControl', '-collectionFile', self.collectionFile, '-showUrl', self.qtUrl]
if os.path.isfile(helpapp) and os.path.isfile(self.collectionFile):
self.assistantProcess.close()
self.assistantProcess.waitForFinished()
@@ -146,98 +147,120 @@ class DGSPlannerGUI(QtGui.QWidget):
else:
mqt.MantidQt.API.MantidDesktopServices.openUrl(QtCore.QUrl(self.externalUrl))
- def closeEvent(self,event):
+ def closeEvent(self, event):
self.assistantProcess.close()
self.assistantProcess.waitForFinished()
event.accept()
+ def _create_goniometer_workspaces(self, gonioAxis0values, gonioAxis1values, gonioAxis2values, progressDialog):
+ groupingStrings = []
+ i = 0
+ for g0 in gonioAxis0values:
+ for g1 in gonioAxis1values:
+ for g2 in gonioAxis2values:
+ name = "__temp_instrument" + str(i)
+ i += 1
+ progressDialog.setValue(i)
+ progressDialog.setLabelText("Creating workspace %d of %d..." % (i, self.iterations))
+ QtGui.qApp.processEvents()
+ if progressDialog.wasCanceled():
+ self.progress_canceled = True
+ progressDialog.close()
+ return None
+
+ groupingStrings.append(name)
+ mantid.simpleapi.CloneWorkspace("__temp_instrument", OutputWorkspace=name)
+ mantid.simpleapi.SetGoniometer(Workspace=name,
+ Axis0=str(g0) + "," + self.masterDict['gonioDirs'][0] +
+ "," + str(self.masterDict['gonioSenses'][0]),
+ Axis1=str(g1) + "," + self.masterDict['gonioDirs'][1] +
+ "," + str(self.masterDict['gonioSenses'][1]),
+ Axis2=str(g2) + "," + self.masterDict['gonioDirs'][2] +
+ "," + str(self.masterDict['gonioSenses'][2]))
+ return groupingStrings
+
# pylint: disable=too-many-locals
def updateFigure(self):
# pylint: disable=too-many-branches
if self.updatedInstrument or self.progress_canceled:
- self.progress_canceled=False
- #get goniometer settings first
- gonioAxis0values=numpy.arange(self.masterDict['gonioMinvals'][0],self.masterDict['gonioMaxvals'][0]
- +0.1*self.masterDict['gonioSteps'][0],self.masterDict['gonioSteps'][0])
- gonioAxis1values=numpy.arange(self.masterDict['gonioMinvals'][1],self.masterDict['gonioMaxvals'][1]
- +0.1*self.masterDict['gonioSteps'][1],self.masterDict['gonioSteps'][1])
- gonioAxis2values=numpy.arange(self.masterDict['gonioMinvals'][2],self.masterDict['gonioMaxvals'][2]
- +0.1*self.masterDict['gonioSteps'][2],self.masterDict['gonioSteps'][2])
- self.iterations=len(gonioAxis0values)*len(gonioAxis1values)*len(gonioAxis2values)
- if self.iterations>10:
- reply = QtGui.QMessageBox.warning(self, 'Goniometer',"More than 10 goniometer settings. This might be long.\n"
- "Are you sure you want to proceed?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,
- QtGui.QMessageBox.No)
- if reply==QtGui.QMessageBox.No:
+ self.progress_canceled = False
+ # get goniometer settings first
+ gonioAxis0values = numpy.arange(self.masterDict['gonioMinvals'][0],
+ self.masterDict['gonioMaxvals'][0] + 0.1 * self.masterDict['gonioSteps'][0],
+ self.masterDict['gonioSteps'][0])
+ gonioAxis1values = numpy.arange(self.masterDict['gonioMinvals'][1],
+ self.masterDict['gonioMaxvals'][1] + 0.1 * self.masterDict['gonioSteps'][1],
+ self.masterDict['gonioSteps'][1])
+ gonioAxis2values = numpy.arange(self.masterDict['gonioMinvals'][2],
+ self.masterDict['gonioMaxvals'][2] + 0.1 * self.masterDict['gonioSteps'][2],
+ self.masterDict['gonioSteps'][2])
+ self.iterations = len(gonioAxis0values) * len(gonioAxis1values) * len(gonioAxis2values)
+ if self.iterations > 10:
+ reply = QtGui.QMessageBox.warning(self, 'Goniometer',
+ "More than 10 goniometer settings. This might be long.\n"
+ "Are you sure you want to proceed?",
+ QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
+ if reply == QtGui.QMessageBox.No:
return
+
if self.wg is not None:
mantid.simpleapi.DeleteWorkspace(self.wg)
- mantid.simpleapi.LoadEmptyInstrument(mantid.api.ExperimentInfo.getInstrumentFilename(self.masterDict['instrument']),
- OutputWorkspace="__temp_instrument")
- if self.masterDict['instrument']=='HYSPEC':
- mantid.simpleapi.AddSampleLog(Workspace="__temp_instrument",LogName='msd',LogText='1798.5',LogType='Number Series')
- mantid.simpleapi.AddSampleLog(Workspace="__temp_instrument",LogName='s2',
- LogText=str(self.masterDict['S2']),LogType='Number Series')
- mantid.simpleapi.LoadInstrument(Workspace="__temp_instrument", RewriteSpectraMap=True, InstrumentName="HYSPEC")
- if self.masterDict['instrument']=='EXED':
+
+ mantid.simpleapi.LoadEmptyInstrument(
+ mantid.api.ExperimentInfo.getInstrumentFilename(self.masterDict['instrument']),
+ OutputWorkspace="__temp_instrument")
+ if self.masterDict['instrument'] == 'HYSPEC':
+ mantid.simpleapi.AddSampleLog(Workspace="__temp_instrument", LogName='msd', LogText='1798.5',
+ LogType='Number Series')
+ mantid.simpleapi.AddSampleLog(Workspace="__temp_instrument", LogName='s2',
+ LogText=str(self.masterDict['S2']), LogType='Number Series')
+ mantid.simpleapi.LoadInstrument(Workspace="__temp_instrument", RewriteSpectraMap=True,
+ InstrumentName="HYSPEC")
+ elif self.masterDict['instrument'] == 'EXED':
mantid.simpleapi.RotateInstrumentComponent(Workspace="__temp_instrument",
ComponentName='Tank',
Y=1,
Angle=str(self.masterDict['S2']),
RelativeRotation=False)
- #masking
- if 'maskFilename' in self.masterDict and len(self.masterDict['maskFilename'].strip())>0:
+ # masking
+ if 'maskFilename' in self.masterDict and len(self.masterDict['maskFilename'].strip()) > 0:
try:
- __maskWS=mantid.simpleapi.Load(self.masterDict['maskFilename'])
- mantid.simpleapi.MaskDetectors(Workspace="__temp_instrument",MaskedWorkspace=__maskWS)
- except (ValueError,RuntimeError) as e:
- reply = QtGui.QMessageBox.critical(self, 'Error',"The following error has occured in loading the mask:\n"+
- str(e)+"\nDo you want to continue without mask?",
- QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
- if reply==QtGui.QMessageBox.No:
+ __maskWS = mantid.simpleapi.Load(self.masterDict['maskFilename'])
+ mantid.simpleapi.MaskDetectors(Workspace="__temp_instrument", MaskedWorkspace=__maskWS)
+ except (ValueError, RuntimeError) as e:
+ reply = QtGui.QMessageBox.critical(self, 'Error',
+ "The following error has occured in loading the mask:\n" +
+ str(e) + "\nDo you want to continue without mask?",
+ QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,
+ QtGui.QMessageBox.No)
+ if reply == QtGui.QMessageBox.No:
return
if self.masterDict['makeFast']:
- sp=list(range(mantid.mtd["__temp_instrument"].getNumberHistograms()))
- tomask=sp[1::4]+sp[2::4]+sp[3::4]
- mantid.simpleapi.MaskDetectors("__temp_instrument",SpectraList=tomask)
- i=0
- groupingStrings=[]
+ sp = list(range(mantid.mtd["__temp_instrument"].getNumberHistograms()))
+ tomask = sp[1::4] + sp[2::4] + sp[3::4]
+ mantid.simpleapi.MaskDetectors("__temp_instrument", SpectraList=tomask)
+
progressDialog = QtGui.QProgressDialog(self)
progressDialog.setMinimumDuration(0)
progressDialog.setCancelButtonText("&Cancel")
progressDialog.setRange(0, self.iterations)
progressDialog.setWindowTitle("DGSPlanner progress")
- for g0 in gonioAxis0values:
- for g1 in gonioAxis1values:
- for g2 in gonioAxis2values:
- name="__temp_instrument"+str(i)
- i+=1
- progressDialog.setValue(i)
- progressDialog.setLabelText("Creating workspace %d of %d..." % (i, self.iterations))
- QtGui.qApp.processEvents()
- if progressDialog.wasCanceled():
- self.progress_canceled=True
- progressDialog.close()
- return
- groupingStrings.append(name)
- mantid.simpleapi.CloneWorkspace("__temp_instrument",OutputWorkspace=name)
- mantid.simpleapi.SetGoniometer(Workspace=name,
- Axis0=str(g0)+","+self.masterDict['gonioDirs'][0]+
- ","+str(self.masterDict['gonioSenses'][0]),
- Axis1=str(g1)+","+self.masterDict['gonioDirs'][1]+
- ","+str(self.masterDict['gonioSenses'][1]),
- Axis2=str(g2)+","+self.masterDict['gonioDirs'][2]+
- ","+str(self.masterDict['gonioSenses'][2]))
+
+ groupingStrings = self._create_goniometer_workspaces(gonioAxis0values, gonioAxis1values, gonioAxis2values,
+ progressDialog)
+ if groupingStrings is None:
+ return
+
progressDialog.close()
mantid.simpleapi.DeleteWorkspace("__temp_instrument")
- self.wg=mantid.simpleapi.GroupWorkspaces(groupingStrings,OutputWorkspace="__temp_instrument")
- self.updatedInstrument=False
- #set the UB
+ self.wg = mantid.simpleapi.GroupWorkspaces(groupingStrings, OutputWorkspace="__temp_instrument")
+ self.updatedInstrument = False
+ # set the UB
if self.updatedOL or not self.wg[0].sample().hasOrientedLattice():
- mantid.simpleapi.SetUB(self.wg,UB=self.ol.getUB())
- self.updatedOL=False
- #calculate coverage
- dimensions=['Q1','Q2','Q3','DeltaE']
+ mantid.simpleapi.SetUB(self.wg, UB=self.ol.getUB())
+ self.updatedOL = False
+ # calculate coverage
+ dimensions = ['Q1', 'Q2', 'Q3', 'DeltaE']
progressDialog = QtGui.QProgressDialog(self)
progressDialog.setMinimumDuration(0)
progressDialog.setCancelButtonText("&Cancel")
@@ -248,53 +271,53 @@ class DGSPlannerGUI(QtGui.QWidget):
progressDialog.setLabelText("Calculating orientation %d of %d..." % (i, self.iterations))
QtGui.qApp.processEvents()
if progressDialog.wasCanceled():
- self.progress_canceled=True
+ self.progress_canceled = True
progressDialog.close()
return
- __mdws=mantid.simpleapi.CalculateCoverageDGS(self.wg[i],
- Q1Basis=self.masterDict['dimBasis'][0],
- Q2Basis=self.masterDict['dimBasis'][1],
- Q3Basis=self.masterDict['dimBasis'][2],
- IncidentEnergy=self.masterDict['Ei'],
- Dimension1=dimensions[self.masterDict['dimIndex'][0]],
- Dimension1Min=float2Input(self.masterDict['dimMin'][0]),
- Dimension1Max=float2Input(self.masterDict['dimMax'][0]),
- Dimension1Step=float2Input(self.masterDict['dimStep'][0]),
- Dimension2=dimensions[self.masterDict['dimIndex'][1]],
- Dimension2Min=float2Input(self.masterDict['dimMin'][1]),
- Dimension2Max=float2Input(self.masterDict['dimMax'][1]),
- Dimension2Step=float2Input(self.masterDict['dimStep'][1]),
- Dimension3=dimensions[self.masterDict['dimIndex'][2]],
- Dimension3Min=float2Input(self.masterDict['dimMin'][2]),
- Dimension3Max=float2Input(self.masterDict['dimMax'][2]),
- Dimension4=dimensions[self.masterDict['dimIndex'][3]],
- Dimension4Min=float2Input(self.masterDict['dimMin'][3]),
- Dimension4Max=float2Input(self.masterDict['dimMax'][3]))
+ __mdws = mantid.simpleapi.CalculateCoverageDGS(self.wg[i],
+ Q1Basis=self.masterDict['dimBasis'][0],
+ Q2Basis=self.masterDict['dimBasis'][1],
+ Q3Basis=self.masterDict['dimBasis'][2],
+ IncidentEnergy=self.masterDict['Ei'],
+ Dimension1=dimensions[self.masterDict['dimIndex'][0]],
+ Dimension1Min=float2Input(self.masterDict['dimMin'][0]),
+ Dimension1Max=float2Input(self.masterDict['dimMax'][0]),
+ Dimension1Step=float2Input(self.masterDict['dimStep'][0]),
+ Dimension2=dimensions[self.masterDict['dimIndex'][1]],
+ Dimension2Min=float2Input(self.masterDict['dimMin'][1]),
+ Dimension2Max=float2Input(self.masterDict['dimMax'][1]),
+ Dimension2Step=float2Input(self.masterDict['dimStep'][1]),
+ Dimension3=dimensions[self.masterDict['dimIndex'][2]],
+ Dimension3Min=float2Input(self.masterDict['dimMin'][2]),
+ Dimension3Max=float2Input(self.masterDict['dimMax'][2]),
+ Dimension4=dimensions[self.masterDict['dimIndex'][3]],
+ Dimension4Min=float2Input(self.masterDict['dimMin'][3]),
+ Dimension4Max=float2Input(self.masterDict['dimMax'][3]))
- if i==0:
- intensity=__mdws.getSignalArray()[:,:,0,0]*1. #to make it writeable
+ if i == 0:
+ intensity = __mdws.getSignalArray()[:, :, 0, 0] * 1. # to make it writeable
else:
if self.colorButton.isChecked():
- tempintensity= __mdws.getSignalArray()[:,:,0,0]
- intensity[numpy.where( tempintensity>0)]=i+1.
+ tempintensity = __mdws.getSignalArray()[:, :, 0, 0]
+ intensity[numpy.where(tempintensity > 0)] = i + 1.
else:
- tempintensity= __mdws.getSignalArray()[:,:,0,0]
- intensity[numpy.where( tempintensity>0)]=1.
+ tempintensity = __mdws.getSignalArray()[:, :, 0, 0]
+ intensity[numpy.where(tempintensity > 0)] = 1.
progressDialog.close()
- x = numpy.linspace(__mdws.getDimension(0).getMinimum(), __mdws.getDimension(0).getMaximum(),intensity.shape[0] )
- y = numpy.linspace(__mdws.getDimension(1).getMinimum(), __mdws.getDimension(1).getMaximum(),intensity.shape[1] )
- Y,X = numpy.meshgrid(y,x)
+ x = numpy.linspace(__mdws.getDimension(0).getMinimum(), __mdws.getDimension(0).getMaximum(), intensity.shape[0])
+ y = numpy.linspace(__mdws.getDimension(1).getMinimum(), __mdws.getDimension(1).getMaximum(), intensity.shape[1])
+ Y, X = numpy.meshgrid(y, x)
xx, yy = self.tr(X, Y)
- Z=numpy.ma.masked_array(intensity,intensity==0)
+ Z = numpy.ma.masked_array(intensity, intensity == 0)
Z = Z[:-1, :-1]
- #plotting
+ # plotting
if self.sender() is self.plotButton or self.needToClear:
self.figure.clear()
self.trajfig.clear()
self.figure.add_subplot(self.trajfig)
- self.needToClear=False
- self.trajfig.pcolorfast(xx,yy,Z)
+ self.needToClear = False
+ self.trajfig.pcolorfast(xx, yy, Z)
if self.aspectButton.isChecked():
self.trajfig.set_aspect(1.)
@@ -307,65 +330,70 @@ class DGSPlannerGUI(QtGui.QWidget):
mantid.simpleapi.DeleteWorkspace(__mdws)
def save(self):
- fileName = str(QtGui.QFileDialog.getSaveFileName(self, 'Save Plot', self.saveDir,'*.png'))
- data = "Instrument "+self.masterDict['instrument']+'\n'
- if self.masterDict['instrument']=='HYSPEC':
- data+= "S2 = "+str(self.masterDict['S2'])+'\n'
- data+= "Ei = "+str(self.masterDict['Ei'])+' meV\n'
- data+= "Goniometer values:\n"
- gonioAxis0values=numpy.arange(self.masterDict['gonioMinvals'][0],self.masterDict['gonioMaxvals'][0]
- +0.1*self.masterDict['gonioSteps'][0],self.masterDict['gonioSteps'][0])
- gonioAxis1values=numpy.arange(self.masterDict['gonioMinvals'][1],self.masterDict['gonioMaxvals'][1]
- +0.1*self.masterDict['gonioSteps'][1],self.masterDict['gonioSteps'][1])
- gonioAxis2values=numpy.arange(self.masterDict['gonioMinvals'][2],self.masterDict['gonioMaxvals'][2]
- +0.1*self.masterDict['gonioSteps'][2],self.masterDict['gonioSteps'][2])
+ fileName = str(QtGui.QFileDialog.getSaveFileName(self, 'Save Plot', self.saveDir, '*.png'))
+ data = "Instrument " + self.masterDict['instrument'] + '\n'
+ if self.masterDict['instrument'] == 'HYSPEC':
+ data += "S2 = " + str(self.masterDict['S2']) + '\n'
+ data += "Ei = " + str(self.masterDict['Ei']) + ' meV\n'
+ data += "Goniometer values:\n"
+ gonioAxis0values = numpy.arange(self.masterDict['gonioMinvals'][0], self.masterDict['gonioMaxvals'][0]
+ + 0.1 * self.masterDict['gonioSteps'][0], self.masterDict['gonioSteps'][0])
+ gonioAxis1values = numpy.arange(self.masterDict['gonioMinvals'][1], self.masterDict['gonioMaxvals'][1]
+ + 0.1 * self.masterDict['gonioSteps'][1], self.masterDict['gonioSteps'][1])
+ gonioAxis2values = numpy.arange(self.masterDict['gonioMinvals'][2], self.masterDict['gonioMaxvals'][2]
+ + 0.1 * self.masterDict['gonioSteps'][2], self.masterDict['gonioSteps'][2])
for g0 in gonioAxis0values:
for g1 in gonioAxis1values:
for g2 in gonioAxis2values:
- data+=" "+self.masterDict['gonioLabels'][0]+" = "+str(g0)
- data+=" "+self.masterDict['gonioLabels'][1]+" = "+str(g1)
- data+=" "+self.masterDict['gonioLabels'][2]+" = "+str(g2)+'\n'
- data+= "Lattice parameters:\n"
- data+=" a = "+str(self.ol.a())+" b = "+str(self.ol.b())+" c = "+str(self.ol.c())+'\n'
- data+=" alpha = "+str(self.ol.alpha())+" beta = "+str(self.ol.beta())+" gamma = "+str(self.ol.gamma())+'\n'
- data+= "Orientation vectors:\n"
- data+=" u = "+str(self.ol.getuVector())+'\n'
- data+=" v = "+str(self.ol.getvVector())+'\n'
- data+="Integrated "+self.masterDict['dimNames'][2]+" between "+\
- str(self.masterDict['dimMin'][2])+" and "+str(self.masterDict['dimMax'][2])+'\n'
- data+="Integrated "+self.masterDict['dimNames'][3]+" between "+\
- str(self.masterDict['dimMin'][3])+" and "+str(self.masterDict['dimMax'][3])+'\n'
+ data += " " + self.masterDict['gonioLabels'][0] + " = " + str(g0)
+ data += " " + self.masterDict['gonioLabels'][1] + " = " + str(g1)
+ data += " " + self.masterDict['gonioLabels'][2] + " = " + str(g2) + '\n'
+ data += "Lattice parameters:\n"
+ data += " a = " + str(self.ol.a()) + " b = " + str(self.ol.b()) + " c = " + str(self.ol.c()) + '\n'
+ data += " alpha = " + str(self.ol.alpha()) + " beta = " + str(self.ol.beta()) + " gamma = " + str(
+ self.ol.gamma()) + '\n'
+ data += "Orientation vectors:\n"
+ data += " u = " + str(self.ol.getuVector()) + '\n'
+ data += " v = " + str(self.ol.getvVector()) + '\n'
+ data += "Integrated " + self.masterDict['dimNames'][2] + " between " + \
+ str(self.masterDict['dimMin'][2]) + " and " + str(self.masterDict['dimMax'][2]) + '\n'
+ data += "Integrated " + self.masterDict['dimNames'][3] + " between " + \
+ str(self.masterDict['dimMin'][3]) + " and " + str(self.masterDict['dimMax'][3]) + '\n'
- info=self.figure.text(0.2,0,data,verticalalignment='top')
- self.figure.savefig(fileName,bbox_inches='tight',additional_artists=info)
- self.saveDir=os.path.dirname(fileName)
+ info = self.figure.text(0.2, 0, data, verticalalignment='top')
+ self.figure.savefig(fileName, bbox_inches='tight', additional_artists=info)
+ self.saveDir = os.path.dirname(fileName)
- def tr(self,x, y):
+ def tr(self, x, y):
x, y = numpy.asarray(x), numpy.asarray(y)
- #one of the axes is energy
- if self.masterDict['dimIndex'][0]==3 or self.masterDict['dimIndex'][1]==3:
- return x,y
+ # one of the axes is energy
+ if self.masterDict['dimIndex'][0] == 3 or self.masterDict['dimIndex'][1] == 3:
+ return x, y
else:
- h1,k1,l1=(float(temp) for temp in self.masterDict['dimBasis'][self.masterDict['dimIndex'][0]].split(','))
- h2,k2,l2=(float(temp) for temp in self.masterDict['dimBasis'][self.masterDict['dimIndex'][1]].split(','))
- angle=numpy.radians(self.ol.recAngle(h1,k1,l1,h2,k2,l2))
- return 1.*x+numpy.cos(angle)*y, numpy.sin(angle)*y
+ h1, k1, l1 = (float(temp) for temp in
+ self.masterDict['dimBasis'][self.masterDict['dimIndex'][0]].split(','))
+ h2, k2, l2 = (float(temp) for temp in
+ self.masterDict['dimBasis'][self.masterDict['dimIndex'][1]].split(','))
+ angle = numpy.radians(self.ol.recAngle(h1, k1, l1, h2, k2, l2))
+ return 1. * x + numpy.cos(angle) * y, numpy.sin(angle) * y
- def inv_tr(self,x,y):
+ def inv_tr(self, x, y):
x, y = numpy.asarray(x), numpy.asarray(y)
- #one of the axes is energy
- if self.masterDict['dimIndex'][0]==3 or self.masterDict['dimIndex'][1]==3:
- return x,y
+ # one of the axes is energy
+ if self.masterDict['dimIndex'][0] == 3 or self.masterDict['dimIndex'][1] == 3:
+ return x, y
else:
- h1,k1,l1=(float(temp) for temp in self.masterDict['dimBasis'][self.masterDict['dimIndex'][0]].split(','))
- h2,k2,l2=(float(temp) for temp in self.masterDict['dimBasis'][self.masterDict['dimIndex'][1]].split(','))
- angle=numpy.radians(self.ol.recAngle(h1,k1,l1,h2,k2,l2))
- return 1.*x-y/numpy.tan(angle), y/numpy.sin(angle)
+ h1, k1, l1 = (float(temp) for temp in
+ self.masterDict['dimBasis'][self.masterDict['dimIndex'][0]].split(','))
+ h2, k2, l2 = (float(temp) for temp in
+ self.masterDict['dimBasis'][self.masterDict['dimIndex'][1]].split(','))
+ angle = numpy.radians(self.ol.recAngle(h1, k1, l1, h2, k2, l2))
+ return 1. * x - y / numpy.tan(angle), y / numpy.sin(angle)
-if __name__=='__main__':
- app=QtGui.QApplication(sys.argv)
- orl=mantid.geometry.OrientedLattice(2,3,4,90,90,90)
- mainForm=DGSPlannerGUI()
+if __name__ == '__main__':
+ app = QtGui.QApplication(sys.argv)
+ orl = mantid.geometry.OrientedLattice(2, 3, 4, 90, 90, 90)
+ mainForm = DGSPlannerGUI()
mainForm.show()
sys.exit(app.exec_())
diff --git a/scripts/HFIRPowderReduction/HfirPDReductionGUI.py b/scripts/HFIRPowderReduction/HfirPDReductionGUI.py
index 31fa2722c954c0dcf379c0121e4e618c4aaef79c..cb8ff17bdb578278a2fe792d51a963beb56cc861 100644
--- a/scripts/HFIRPowderReduction/HfirPDReductionGUI.py
+++ b/scripts/HFIRPowderReduction/HfirPDReductionGUI.py
@@ -1,4 +1,4 @@
-#pylint: disable=invalid-name, relative-import, too-many-lines,too-many-instance-attributes,too-many-arguments
+# pylint: disable=invalid-name, relative-import, too-many-lines,too-many-instance-attributes,too-many-arguments
################################################################################
# Main class for HFIR powder reduction GUI
# Key word for future developing: FUTURE, NEXT, REFACTOR, RELEASE 2.0
@@ -8,14 +8,15 @@ from __future__ import (absolute_import, division, print_function)
from six.moves import range
import numpy
import os
+
try:
import urllib.request as urllib
except ImportError:
- import urllib
-
+ import urllib
-from .ui_MainWindow import Ui_MainWindow #import line for the UI python class
+from .ui_MainWindow import Ui_MainWindow # import line for the UI python class
from PyQt4 import QtCore, QtGui
+
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
@@ -26,11 +27,13 @@ import mantid
import mantidqtpython as mqt
from . import HfirPDReductionControl
-#----- default configuration ---------------
+# ----- default configuration ---------------
DEFAULT_SERVER = 'http://neutron.ornl.gov/user_data'
DEFAULT_INSTRUMENT = 'hb2a'
DEFAULT_WAVELENGTH = 2.4100
-#-------------------------------------------
+
+
+# -------------------------------------------
class EmptyError(Exception):
@@ -97,7 +100,7 @@ class MultiScanTabState(object):
"""
return self._scanList[:]
- #pyline: disable=too-many-arguments
+ # pyline: disable=too-many-arguments
def setup(self, exp_no, scan_list, min_x, max_x, bin_size, unit, raw, correct_det_eff, exclude_dets):
"""
Set up the object
@@ -127,7 +130,7 @@ class MultiScanTabState(object):
return
-#pylint: disable=too-many-public-methods,too-many-branches,too-many-locals,too-many-statements
+# pylint: disable=too-many-public-methods,too-many-branches,too-many-locals,too-many-statements
class MainWindow(QtGui.QMainWindow):
""" Class of Main Window (top)
"""
@@ -144,7 +147,7 @@ class MainWindow(QtGui.QMainWindow):
""" Initialization and set up
"""
# Base class
- QtGui.QMainWindow.__init__(self,parent)
+ QtGui.QMainWindow.__init__(self, parent)
# UI Window (from Qt Designer)
self.ui = Ui_MainWindow()
@@ -185,7 +188,7 @@ class MainWindow(QtGui.QMainWindow):
self.doPlotIndvDetNext)
self.connect(self.ui.pushButton_clearCanvasIndDet, QtCore.SIGNAL('clicked()'),
self.doClearIndDetCanvas)
- self.connect(self.ui.pushButton_plotLog , QtCore.SIGNAL('clicked()'),
+ self.connect(self.ui.pushButton_plotLog, QtCore.SIGNAL('clicked()'),
self.do_plot_sample_log)
# tab 'Normalized'
@@ -337,7 +340,7 @@ class MainWindow(QtGui.QMainWindow):
self._instrument = str(self.ui.comboBox_instrument.currentText())
# UI widgets setup
- self.ui.comboBox_outputFormat.addItems(['Fullprof']) # Supports Fullprof only now, 'GSAS', 'Fullprof+GSAS'])
+ self.ui.comboBox_outputFormat.addItems(['Fullprof']) # Supports Fullprof only now, 'GSAS', 'Fullprof+GSAS'])
# RELEASE 2.0 : Need to disable some widgets... consider to refactor the code
self.ui.radioButton_useServer.setChecked(True)
@@ -394,23 +397,20 @@ class MainWindow(QtGui.QMainWindow):
self._multiScanExp = None
self._multiScanList = []
- #help
+ # help
self.assistantProcess = QtCore.QProcess(self)
# pylint: disable=protected-access
- self.collectionFile=os.path.join(mantid._bindir,'../docs/qthelp/MantidProject.qhc')
+ self.collectionFile = os.path.join(mantid._bindir, '../docs/qthelp/MantidProject.qhc')
version = ".".join(mantid.__version__.split(".")[:2])
- self.qtUrl='qthelp://org.sphinx.mantidproject.'+version+'/doc/interfaces/HFIRPowderReduction.html'
- self.externalUrl='http://docs.mantidproject.org/nightly/interfaces/HFIRPowderReduction.html'
+ self.qtUrl = 'qthelp://org.sphinx.mantidproject.' + version + '/doc/interfaces/HFIRPowderReduction.html'
+ self.externalUrl = 'http://docs.mantidproject.org/nightly/interfaces/HFIRPowderReduction.html'
# Initial setup for tab
self.ui.tabWidget.setCurrentIndex(0)
cache_dir = str(self.ui.lineEdit_cache.text()).strip()
if len(cache_dir) == 0 or os.path.exists(cache_dir) is False:
invalid_cache = cache_dir
- if False:
- cache_dir = os.path.expanduser('~')
- else:
- cache_dir = os.getcwd()
+ cache_dir = os.getcwd()
self.ui.lineEdit_cache.setText(cache_dir)
self._logWarning("Cache directory %s is not valid. "
"Using current workspace directory %s as cache." %
@@ -427,14 +427,13 @@ class MainWindow(QtGui.QMainWindow):
uselocal = False
self.ui.radioButton_useServer.setChecked(True)
self.ui.radioButton_useLocal.setChecked(False)
- # ENDIF
- #register startup
- mantid.UsageService.registerFeatureUsage("Interface","HfirPowderReduction",False)
+ # register startup
+ mantid.UsageService.registerFeatureUsage("Interface", "HfirPowderReduction", False)
return
- #-- Event Handling ----------------------------------------------------
+ # -- Event Handling ----------------------------------------------------
def doBrowseCache(self):
""" Pop out a dialog to let user specify the directory to
@@ -448,7 +447,7 @@ class MainWindow(QtGui.QMainWindow):
home = os.getcwd()
# pop out a dialog
- dirs = str(QtGui.QFileDialog.getExistingDirectory(self,'Get Directory',home))
+ dirs = str(QtGui.QFileDialog.getExistingDirectory(self, 'Get Directory', home))
# set to line edit
if dirs != home:
@@ -482,16 +481,12 @@ class MainWindow(QtGui.QMainWindow):
if len(textbuf) > 0:
textbuf = textbuf[:-1]
self.ui.lineEdit_detExcluded.setText(textbuf)
- # ENDIF
-
- return
def doBrowseLocalDataSrc(self):
""" Browse local data storage
"""
msg = "Browse local data storage location. Implement ASAP"
QtGui.QMessageBox.information(self, "Click!", msg)
- return
def doChangeSrcLocation(self):
""" Source file location is changed
@@ -502,8 +497,7 @@ class MainWindow(QtGui.QMainWindow):
print("Use Server: ", useserver)
print("Use Local : ", uselocal)
- if (useserver is True and uselocal is True) or \
- (useserver is False and uselocal is False):
+ if (useserver and uselocal) or not (useserver or uselocal):
raise NotImplementedError("Impossible for radio buttons")
self._srcAtLocal = uselocal
@@ -521,16 +515,12 @@ class MainWindow(QtGui.QMainWindow):
self.ui.lineEdit_localSrc.setDisabled(True)
self.ui.pushButton_browseLocalSrc.setDisabled(True)
- return
-
def doCheckSrcServer(self):
"""" Check source data server's availability
"""
msg = "Check source data server! Implement ASAP"
QtGui.QMessageBox.information(self, "Click!", msg)
- return
-
def doClearCanvas(self):
""" Clear canvas
"""
@@ -539,8 +529,6 @@ class MainWindow(QtGui.QMainWindow):
self.ui.graphicsView_reducedData.clearAllLines()
self._tabLineDict[itab] = []
- return
-
def doClearIndDetCanvas(self):
""" Clear the canvas in tab 'Individual Detector' and current plotted lines
in managing dictionary
@@ -553,8 +541,6 @@ class MainWindow(QtGui.QMainWindow):
# Reset colur schedule
self.ui.graphicsView_indvDet.resetLineColorStyle()
- return
-
def doClearMultiRunCanvas(self):
""" Clear the canvas in tab 'Multiple Run'
@@ -563,8 +549,6 @@ class MainWindow(QtGui.QMainWindow):
"""
self.ui.graphicsView_mergeRun.clearCanvas()
- return
-
def doClearRawDetCanvas(self):
""" Clear the canvas in tab 'Raw Detector':
only need to clear lines
@@ -572,27 +556,21 @@ class MainWindow(QtGui.QMainWindow):
self.ui.graphicsView_Raw.clearAllLines()
self._tabLineDict[self.ui.graphicsView_Raw] = []
- return
-
def doClearVanadiumCanvas(self):
""" Clear the canvas in tab 'Vanadium'
"""
self.ui.graphicsView_vanPeaks.clearAllLines()
- return
-
def doExist(self):
""" Exist the application
"""
clearcache = self.ui.checkBox_delCache.isChecked()
- if clearcache is True:
+ if clearcache:
urllib.delAllFile(self._cache)
self.close()
- return
-
def doHelp(self):
""" Show help
Copied from DGSPlanner
@@ -601,7 +579,7 @@ class MainWindow(QtGui.QMainWindow):
self.assistantProcess.waitForFinished()
helpapp = QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.BinariesPath) + QtCore.QDir.separator()
helpapp += 'assistant'
- args = ['-enableRemoteControl', '-collectionFile',self.collectionFile,'-showUrl',self.qtUrl]
+ args = ['-enableRemoteControl', '-collectionFile', self.collectionFile, '-showUrl', self.qtUrl]
if os.path.isfile(helpapp) and os.path.isfile(self.collectionFile):
self.assistantProcess.close()
self.assistantProcess.waitForFinished()
@@ -611,203 +589,198 @@ class MainWindow(QtGui.QMainWindow):
mqt.MantidQt.API.MantidDesktopServices.openUrl(QtCore.QUrl(self.externalUrl))
print("Show help from (url)", QtCore.QUrl(self.externalUrl))
- return
-
- def doLoadData(self, exp=None, scan=None):
- """ Load and reduce data
- It does not support for tab 'Advanced Setup'
- For tab 'Raw Detector' and 'Individual Detector', this method will load data to MDEventWorkspaces
- For tab 'Normalized' and 'Vanadium', this method will load data to MDEVentWorkspaces but NOT reduce to single spectrum
- """
- # Kick away unsupported tabs
- itab = self.ui.tabWidget.currentIndex()
- tabtext = str(self.ui.tabWidget.tabText(itab))
- print("[DB] Current active tab is No. %d as %s." % (itab, tabtext))
-
- # Rule out unsupported tab
- if itab == 5:
- # 'advanced'
- msg = "Tab %s does not support 'Load Data'. Request is ambiguous." % tabtext
- QtGui.QMessageBox.information(self, "Click!", msg)
- return
-
- # Get exp number and scan number
- if isinstance(exp, int) is True and isinstance(scan, int) is True:
- # use input
- expno = exp
- scanno = scan
- else:
- # read from GUI
- try:
- expno, scanno = self._uiGetExpScanNumber()
- self._logDebug("Attending to load Exp %d Scan %d." % (expno, scanno))
- except NotImplementedError as ne:
- self._logError("Error to get Exp and Scan due to %s." % (str(ne)))
- return
- # ENDIF
-
- # Form data file name and download data
- status, datafilename = self._uiDownloadDataFile(exp=expno, scan=scanno)
- if status is False:
- self._logError("Unable to download or locate local data file for Exp %d \
- Scan %d." % (expno, scanno))
- # ENDIF(status)
-
- # (Load data for tab 0, 1, 2 and 4)
- if itab not in [0, 1, 2, 3, 4]:
- # Unsupported Tabs: programming error!
- errmsg = "%d-th tab should not get this far.\n"%(itab)
- errmsg += 'GUI has been changed, but the change has not been considered! iTab = %d' % (itab)
- raise NotImplementedError(errmsg)
-
- # Load SPICE data to raw table (step 1)
+ def _load_spice_data_to_raw_table(self, exp_no, scan_no, data_file_name):
try:
- execstatus = self._myControl.loadSpicePDData(expno, scanno, datafilename)
- if execstatus is False:
- cause = "Load data failed."
- else:
- cause = None
+ success = self._myControl.loadSpicePDData(exp_no, scan_no, data_file_name)
+ return success, "" if success else "Load data failed."
except NotImplementedError as ne:
- execstatus = False
- cause = str(ne)
- # END-TRY-EXCEPT
-
- # Return as failed to load data
- if execstatus is False:
- self._logError(cause)
- return
+ return False, str(ne)
+ def _get_corr_file_names_and_wavelength(self, exp_no, scan_no, data_file_name):
# Obtain the correction file names and wavelength from SPICE file
- wavelengtherror = False
- errmsg = ""
- localdir = os.path.dirname(datafilename)
+ wavelength_error = False
+ err_msg = ""
+ local_dir = os.path.dirname(data_file_name)
try:
- status, returnbody = self._myControl.retrieveCorrectionData(instrument='HB2A',
- exp=expno, scan=scanno,
- localdatadir=localdir)
+ status, return_body = self._myControl.retrieveCorrectionData(instrument='HB2A',
+ exp=exp_no, scan=scan_no,
+ localdatadir=local_dir)
except NotImplementedError as e:
- errmsg = str(e)
- if errmsg.count('m1') > 0:
+ err_msg = str(e)
+ if err_msg.count('m1') > 0:
# error is about wavelength
status = False
- wavelengtherror = True
+ wavelength_error = True
else:
# other error
raise e
- # ENDTRY
- if status is True:
- autowavelength = returnbody[0]
- vancorrfname = returnbody[1]
- excldetfname = returnbody[2]
+ if status:
+ auto_wavelength = return_body[0]
+ van_corr_filename = return_body[1]
+ excl_det_filename = return_body[2]
- if vancorrfname is not None:
- self.ui.lineEdit_vcorrFileName.setText(vancorrfname)
- if excldetfname is not None:
- self.ui.lineEdit_excludedDetFileName.setText(excldetfname)
+ if van_corr_filename is not None:
+ self.ui.lineEdit_vcorrFileName.setText(van_corr_filename)
+ if excl_det_filename is not None:
+ self.ui.lineEdit_excludedDetFileName.setText(excl_det_filename)
else:
- autowavelength = None
- vancorrfname = None
- excldetfname = None
- # ENDIF
+ auto_wavelength = None
+ van_corr_filename = None
+ excl_det_filename = None
+ return auto_wavelength, van_corr_filename, excl_det_filename, wavelength_error, err_msg
- # Set wavelength to GUI except 'multiple scans'
- if autowavelength is None:
+ def _set_wavelength(self, auto_wavelength, wavelength_error, exp_no, scan_no, err_msg):
+ if auto_wavelength is None:
# unable to get wavelength from SPICE data
self.ui.comboBox_wavelength.setCurrentIndex(4)
- if wavelengtherror is True:
- self.ui.lineEdit_wavelength.setText(errmsg)
+ if wavelength_error:
+ self.ui.lineEdit_wavelength.setText(err_msg)
else:
self.ui.lineEdit_wavelength.setText(self.ui.comboBox_wavelength.currentText())
- self._myControl.setWavelength(expno, scanno, wavelength=None)
+ self._myControl.setWavelength(exp_no, scan_no, wavelength=None)
else:
# get wavelength from SPICE data. set value to GUI
- self.ui.lineEdit_wavelength.setText(str(autowavelength))
- allowedwavelengths = [2.41, 1.54, 1.12]
- numitems = self.ui.comboBox_wavelength.count()
+ self.ui.lineEdit_wavelength.setText(str(auto_wavelength))
+ allowed_wavelengths = [2.41, 1.54, 1.12]
+ num_items = self.ui.comboBox_wavelength.count()
good = False
- for ic in range(numitems-1):
- if abs(autowavelength - allowedwavelengths[ic]) < 0.01:
+ for ic in range(num_items - 1):
+ if abs(auto_wavelength - allowed_wavelengths[ic]) < 0.01:
good = True
self.ui.comboBox_wavelength.setCurrentIndex(ic)
- # ENDFOR
- if good is False:
- self.ui.comboBox_wavelength.setCurrentIndex(numitems-1)
- # ENDIF
+ if not good:
+ self.ui.comboBox_wavelength.setCurrentIndex(num_items - 1)
- self._myControl.setWavelength(expno, scanno, wavelength=autowavelength)
- # ENDIFELSE
+ self._myControl.setWavelength(exp_no, scan_no, wavelength=auto_wavelength)
- # Optionally obtain and parse det effecient file
- if self.ui.checkBox_useDetEffCorr.isChecked() is True:
+ def _get_and_parse_det_efficiency_file(self, van_corr_filename):
+ if self.ui.checkBox_useDetEffCorr.isChecked():
# Apply detector efficiency correction
- if vancorrfname is None:
+ if van_corr_filename is None:
# browse vanadium correction file
- filefilter = "Text (*.txt);;Data (*.dat);;All files (*)"
- curDir = os.getcwd()
- vancorrfnames = QtGui.QFileDialog.getOpenFileNames(self, 'Open File(s)', curDir, filefilter)
- if len(vancorrfnames) > 0:
- vancorrfname = vancorrfnames[0]
- self.ui.lineEdit_vcorrFileName.setText(str(vancorrfname))
+ file_filter = "Text (*.txt);;Data (*.dat);;All files (*)"
+ current_dir = os.getcwd()
+ van_corr_filenames = QtGui.QFileDialog.getOpenFileNames(self, 'Open File(s)', current_dir, file_filter)
+ if len(van_corr_filenames) > 0:
+ van_corr_filename = van_corr_filenames[0]
+ self.ui.lineEdit_vcorrFileName.setText(str(van_corr_filename))
else:
self._logError("User does not specify any vanadium correction file.")
self.ui.checkBox_useDetEffCorr.setChecked(False)
- # ENDIF-len()
- # ENDIF vancorrfname
# Parse if it is not None
- if vancorrfname is not None:
- detefftablews, errmsg = self._myControl.parseDetEffCorrFile('HB2A', vancorrfname)
- if detefftablews is None:
- print("Parsing detectors efficiency file error: %s." % (errmsg))
+ if van_corr_filename is not None:
+ detector_efficiency_ws, err_msg = self._myControl.parseDetEffCorrFile('HB2A', van_corr_filename)
+ if detector_efficiency_ws is None:
+ print("Parsing detectors efficiency file error: {0}.".format(err_msg))
+ return None
+ else:
+ return detector_efficiency_ws
else:
- detefftablews = None
- # ENDIF
+ return None
else:
# Not chosen to apply detector efficiency correction:w
- detefftablews = None
- # ENDIF
+ return None
- # Parse SPICE data to MDEventWorkspaces
+ def _parse_spice_data_to_MDEventWS(self, detector_efficiency_table, exp_no, scan_no):
try:
- print("Det Efficiency Table WS: ", str(detefftablews))
- execstatus = self._myControl.parseSpiceData(expno, scanno, detefftablews)
- if execstatus is False:
- cause = "Parse data failed."
- else:
- cause = None
+ print("Det Efficiency Table WS: ", str(detector_efficiency_table))
+ exec_status = self._myControl.parseSpiceData(exp_no, scan_no, detector_efficiency_table)
+ return exec_status, "" if exec_status else "Parse data failed."
except NotImplementedError as e:
- execstatus = False
- cause = str(e)
- # END-TRY-EXCEPT-FINALLY
+ return False, str(e)
+
+ def _parse_detector_exclusion_file(self, exclude_detector_filename):
+ if exclude_detector_filename is not None:
+ exclude_detector_list, err_msg = self._myControl.parseExcludedDetFile('HB2A', exclude_detector_filename)
+
+ text_buf = ""
+ for det_id in exclude_detector_list:
+ text_buf += "{0},".format(det_id)
+ if len(text_buf) > 0:
+ text_buf = text_buf[:-1]
+ self.ui.lineEdit_detExcluded.setText(text_buf)
+
+ def doLoadData(self, exp=None, scan=None):
+ """ Load and reduce data
+ It does not support for tab 'Advanced Setup'
+ For tab 'Raw Detector' and 'Individual Detector', this method will load data to MDEventWorkspaces
+ For tab 'Normalized' and 'Vanadium', this method will load data to MDEVentWorkspaces but NOT reduce to single spectrum
+ """
+ # Kick away unsupported tabs
+ i_tab = self.ui.tabWidget.currentIndex()
+ tab_text = str(self.ui.tabWidget.tabText(i_tab))
+ print("[DB] Current active tab is No. {0} as {1}.".format(i_tab, tab_text))
- # Return if data parsing is error
- if execstatus is False:
- self._logError(cause)
+ # Rule out unsupported tab
+ if i_tab == 5:
+ # 'advanced'
+ msg = "Tab {0} does not support 'Load Data'. Request is ambiguous.".format(tab_text)
+ QtGui.QMessageBox.information(self, "Click!", msg)
return
- # Optionally parse detector exclusion file and set to line text
- if excldetfname is not None:
- excludedetlist, errmsg = self._myControl.parseExcludedDetFile('HB2A', excldetfname)
+ # Get exp number and scan number
+ if isinstance(exp, int) and isinstance(scan, int):
+ # use input
+ exp_no = exp
+ scan_no = scan
+ else:
+ # read from GUI
+ try:
+ exp_no, scan_no = self._uiGetExpScanNumber()
+ self._logDebug("Attending to load Exp {0} Scan {1}.".format(exp_no, scan_no))
+ except NotImplementedError as ne:
+ self._logError("Error to get Exp and Scan due to {0}.".format(str(ne)))
+ return
+
+ # Form data file name and download data
+ status, data_filename = self._uiDownloadDataFile(exp=exp_no, scan=scan_no)
+ if not status:
+ self._logError("Unable to download or locate local data file for Exp {0} Scan {1}.".format(exp_no, scan_no))
+
+ # (Load data for tab 0, 1, 2 and 4)
+ if i_tab not in [0, 1, 2, 3, 4]:
+ # Unsupported Tabs: programming error!
+ err_msg = "{0}-th tab should not get this far.\n".format(i_tab)
+ err_msg += 'GUI has been changed, but the change has not been considered! iTab = {0}'.format(i_tab)
+ raise NotImplementedError(err_msg)
- textbuf = ""
- for detid in excludedetlist:
- textbuf += "%d," % (detid)
- if len(textbuf) > 0:
- textbuf = textbuf[:-1]
- self.ui.lineEdit_detExcluded.setText(textbuf)
- # ENDIF
+ # Load SPICE data to raw table (step 1)
+ load_success, msg = self._load_spice_data_to_raw_table(exp_no, scan_no, data_filename)
+ if not load_success:
+ self._logError(msg)
+ return
+
+ # Obtain the correction file names and wavelength from SPICE file
+ (auto_wavelength, van_corr_filename, exclude_detector_filename, wavelength_error, err_msg) \
+ = self._load_spice_data_to_raw_table(exp_no, scan_no, data_filename)
+
+ # Set wavelength to GUI except 'multiple scans'
+ self._set_wavelength(auto_wavelength, wavelength_error, exp_no, scan_no, err_msg)
+
+ # Optionally obtain and parse det effecient file
+ detector_efficiency_table_ws = self._get_and_parse_det_efficiency_file(van_corr_filename)
+
+ # Parse SPICE data to MDEventWorkspaces
+ success, msg = self._parse_spice_data_to_MDEventWS(detector_efficiency_table_ws, exp_no, scan_no)
+ if not success:
+ self._logError(msg)
+ return
+
+ # Optionally parse detector exclusion file and set to line text
+ self._parse_detector_exclusion_file(exclude_detector_filename)
# Set up some widgets for raw detector data. Won't be applied to tab 3
- if itab != 3:
- floatsamplelognamelist = self._myControl.getSampleLogNames(expno, scanno)
+ if i_tab != 3:
+ float_sample_log_name_list = self._myControl.getSampleLogNames(exp_no, scan_no)
self.ui.comboBox_indvDetXLabel.clear()
self.ui.comboBox_indvDetXLabel.addItem("2theta/Scattering Angle")
- self.ui.comboBox_indvDetXLabel.addItems(floatsamplelognamelist)
+ self.ui.comboBox_indvDetXLabel.addItems(float_sample_log_name_list)
self.ui.comboBox_indvDetYLabel.clear()
- self.ui.comboBox_indvDetYLabel.addItems(floatsamplelognamelist)
+ self.ui.comboBox_indvDetYLabel.addItems(float_sample_log_name_list)
return True
@@ -827,16 +800,15 @@ class MainWindow(QtGui.QMainWindow):
loadstatus = True
for scan in sorted(scanlist):
tempstatus = self.doLoadData(expno, scan)
- if tempstatus is False:
- self.ui.label_mergeMessage.setText('Error to load Exp %d Scan %d.'%(expno, scan))
+ if not tempstatus:
+ self.ui.label_mergeMessage.setText('Error to load Exp %d Scan %d.' % (expno, scan))
loadstatus = False
else:
message = 'Loaded Exp %d Scan %d.' % (expno, scan)
self.ui.label_mergeMessage.setText(message)
- # ENDFOR
# Load status
- if loadstatus is True:
+ if loadstatus:
self.ui.label_mergeMessage.setText('All data files are loaded')
else:
self.ui.label_mergeMessage.setText('Not all data files are loaded')
@@ -848,10 +820,9 @@ class MainWindow(QtGui.QMainWindow):
self._logNotice("Exp %d Scan %d has no wavelength set up." % (expno, scan))
haswavelength = False
break
- # ENDFOR
# Set unit box
- if haswavelength is True:
+ if haswavelength:
self.ui.comboBox_mscanUnit.clear()
self.ui.comboBox_mscanUnit.addItems(['2theta', 'dSpacing', 'Momentum Transfer (Q)'])
else:
@@ -883,8 +854,6 @@ class MainWindow(QtGui.QMainWindow):
# Reduce data
self._uiReducePlotNoramlized(self._currUnit)
- return
-
def doLoadReduceScanNext(self):
""" Load and reduce next scan for tab 'Normalized'
"""
@@ -908,8 +877,6 @@ class MainWindow(QtGui.QMainWindow):
# Reduce data
self._uiReducePlotNoramlized(self._currUnit)
- return
-
def doMergeScans(self):
""" Merge several scans for tab 'merge'
"""
@@ -926,7 +893,8 @@ class MainWindow(QtGui.QMainWindow):
try:
wl_list = []
for scanno in scanlist:
- print("Exp %d Scan %d. Wavelength = %s." % (expno, scanno, str(self._myControl.getWavelength(expno, scanno))))
+ print("Exp %d Scan %d. Wavelength = %s." % (
+ expno, scanno, str(self._myControl.getWavelength(expno, scanno))))
wl_list.append(float(self._myControl.getWavelength(expno, scanno)))
wl_list = sorted(wl_list)
@@ -942,7 +910,7 @@ class MainWindow(QtGui.QMainWindow):
try:
unit = str(self.ui.comboBox_mscanUnit.currentText())
xmin, binsize, xmax = self._uiGetBinningParams(itab=3)
- #wavelength = min_wl
+ # wavelength = min_wl
mindex = self._myControl.mergeReduceSpiceData(expno, scanlist, unit, xmin, xmax, binsize)
except Exception as e:
raise e
@@ -982,11 +950,8 @@ class MainWindow(QtGui.QMainWindow):
xlabel = self._getXLabelFromUnit(unit)
for scanno in scanlist:
- label = "Exp %s Scan %s"%(str(expno), str(scanno))
+ label = "Exp %s Scan %s" % (str(expno), str(scanno))
self._plotReducedData(expno, scanno, canvas, xlabel, label=label, clearcanvas=False)
- # ENDFOR
-
- return
def doMergeScanView2D(self):
""" Change the merged run's view to 2D plot
@@ -1013,29 +978,20 @@ class MainWindow(QtGui.QMainWindow):
vecylist.append(vecy)
yticklabels.append('Exp %d Scan %d' % (expno, scanno))
- #print "[DB] Scan ", scanno, ": X range: ", vecx[0], vecx[-1], " Size X = ", len(vecx)
# set up range of x
if xmin is None:
xmin = vecx[0]
xmax = vecx[-1]
- # ENDIF
- # ENDFOR
dim2array = numpy.array(vecylist)
- #print "2D vector: \n", dim2array
- #print "x range: %f, %f" % (xmin, xmax)
- #print "y labels: ", yticklabels
-
# Plot
- holdprev=False
+ holdprev = False
self.ui.graphicsView_mergeRun.clearAllLines()
self.ui.graphicsView_mergeRun.addPlot2D(dim2array, xmin=xmin, xmax=xmax, ymin=0,
ymax=len(vecylist), holdprev=holdprev, yticklabels=yticklabels)
- return
-
def doMergeScanViewMerged(self):
""" Change the merged run's view to 1D plot
"""
@@ -1051,8 +1007,6 @@ class MainWindow(QtGui.QMainWindow):
# Plot
self._plotMergedReducedData(mkey=self._lastMergeIndex, label=self._lastMergeLabel)
- return
-
def doPlotIndvDetMain(self):
""" Plot individual detector
"""
@@ -1069,10 +1023,10 @@ class MainWindow(QtGui.QMainWindow):
status, detidlist = self._getIntArray(self.ui.lineEdit_detID.text())
if status is False:
errmsg = detidlist
- print("Unable to parse detector IDs due to %s."%(errmsg))
+ print("Unable to parse detector IDs due to %s." % (errmsg))
return
else:
- print("[DB] Detectors to plot: %s"%(detidlist))
+ print("[DB] Detectors to plot: %s" % (detidlist))
except EmptyError:
self._logError("Detector ID must be specified for plotting individual detector.")
return
@@ -1105,8 +1059,6 @@ class MainWindow(QtGui.QMainWindow):
except NotImplementedError as e:
self._logError(str(e))
- return
-
def doPlotIndvDetNext(self):
""" Plot next raw detector signals for tab 'Individual Detector'
"""
@@ -1129,8 +1081,6 @@ class MainWindow(QtGui.QMainWindow):
# Update widget
self.ui.lineEdit_detID.setText(str(self._detID))
- return
-
def doPlotIndvDetPrev(self):
""" Plot previous individual detector's signal for tab 'Individual Detector'
"""
@@ -1153,8 +1103,6 @@ class MainWindow(QtGui.QMainWindow):
# Update widget
self.ui.lineEdit_detID.setText(str(self._detID))
- return
-
def do_convert_plot_multi_scans(self):
""" Convert individual plots from normalized to raw or vice verse
"""
@@ -1203,9 +1151,8 @@ class MainWindow(QtGui.QMainWindow):
xlabel = self._getXLabelFromUnit(unit)
for scan_no in scan_list:
- label = "Exp %s Scan %s"%(str(exp_no), str(scan_no))
+ label = "Exp %s Scan %s" % (str(exp_no), str(scan_no))
self._plotReducedData(exp_no, scan_no, canvas, xlabel, label=label, clearcanvas=False)
- # END_FOR
# Change the button name
if new_mode == 'Plot Raw':
@@ -1213,8 +1160,6 @@ class MainWindow(QtGui.QMainWindow):
else:
self.ui.pushButton_plotRawMultiScans.setText('Plot Raw')
- return
-
def doPlotRawPtMain(self):
""" Plot current raw detector signal for a specific Pt.
"""
@@ -1247,8 +1192,6 @@ class MainWindow(QtGui.QMainWindow):
else:
print("[Error] Execution fails with signal %s. " % (str(execstatus)))
- return
-
def doPlotRawPtNext(self):
""" Plot next raw detector signals
"""
@@ -1259,7 +1202,6 @@ class MainWindow(QtGui.QMainWindow):
self._logError("Unable to plot previous raw detector \
because Pt. or Detector ID has not been set up yet.")
return
- # EndIfElse
# Get plot mode and plot
plotmode = str(self.ui.comboBox_rawDetMode.currentText())
@@ -1268,23 +1210,19 @@ class MainWindow(QtGui.QMainWindow):
ptno, overplot)
# update if it is good to plot
- if execstatus is True:
+ if execstatus:
self._rawDetPtNo = ptno
self.ui.lineEdit_ptNo.setText(str(ptno))
- return
-
def do_enable_excluded_dets(self):
""" Enable or disable the line editor for excluded detectors
:return:
"""
- if self.ui.checkBox_useDetExcludeFile.isChecked() is True:
+ if self.ui.checkBox_useDetExcludeFile.isChecked():
self.ui.lineEdit_detExcluded.setEnabled(True)
else:
self.ui.lineEdit_detExcluded.setDisabled(True)
- return
-
def do_plot_raw_pt_prev(self):
""" Plot previous raw detector
"""
@@ -1303,30 +1241,24 @@ class MainWindow(QtGui.QMainWindow):
ptno, overplot)
# update if it is good to plot
- if execstatus is True:
+ if execstatus:
self._rawDetPtNo = ptno
self.ui.lineEdit_ptNo.setText(str(ptno))
- return
-
def do_plot_sample_log(self):
""" Plot sample log vs. Pt. in tab 'Individual Detector'
"""
- expNo = int(self.ui.lineEdit_expNo.text())
+ expNo = int(self.ui.lineEdit_expNo.text())
scanno = int(self.ui.lineEdit_scanNo.text())
logname = str(self.ui.comboBox_indvDetYLabel.currentText())
self._plotSampleLog(expNo, scanno, logname)
- return
-
def doReduce2Theta(self):
""" Rebin the data and plot in 2theta for tab 'Normalized'
"""
unit = '2theta'
self._uiReducePlotNoramlized(unit)
- return
-
def doReduceDSpacing(self):
""" Rebin the data and plot in d-spacing for tab 'Normalized'
"""
@@ -1334,16 +1266,12 @@ class MainWindow(QtGui.QMainWindow):
unit = "dSpacing"
self._uiReducePlotNoramlized(unit)
- return
-
def doReduceQ(self):
""" Rebin the data and plot in momentum transfer Q for tab 'Normalized'
"""
unit = 'Momentum Transfer (Q)'
self._uiReducePlotNoramlized(unit)
- return
-
def doReduceSetData(self):
""" Reduce multiple data
"""
@@ -1375,14 +1303,10 @@ class MainWindow(QtGui.QMainWindow):
scanno = r[2]
if good is True:
- label = "Exp %s Scan %s"%(str(expno), str(scanno))
+ label = "Exp %s Scan %s" % (str(expno), str(scanno))
self._plotReducedData(expno, scanno, canvas, xlabel, label=label, clearcanvas=False)
else:
- self._logError('Failed to reduce Exp %s Scan %s'%(str(expno), str(scanno)))
- # ENDIF
- # ENDFOR
-
- return
+ self._logError('Failed to reduce Exp %s Scan %s' % (str(expno), str(scanno)))
def doReduceVanadium2Theta(self):
""" Rebin MDEventWorkspaces in 2-theta. for pushButton_rebinD
@@ -1405,7 +1329,7 @@ class MainWindow(QtGui.QMainWindow):
if good is True:
canvas = self.ui.graphicsView_vanPeaks
xlabel = self._getXLabelFromUnit(unit)
- label = "Exp %s Scan %s"%(str(expno), str(scanno))
+ label = "Exp %s Scan %s" % (str(expno), str(scanno))
self._plotReducedData(expno, scanno, canvas, xlabel, label=label, clearcanvas=True)
# plot vanadium peaks
@@ -1438,8 +1362,6 @@ class MainWindow(QtGui.QMainWindow):
else:
self._myControl.savePDFile(expno, scanno, filetype, sfilename)
- return
-
def doSaveMergedScan(self):
""" Save merged scan
"""
@@ -1449,8 +1371,6 @@ class MainWindow(QtGui.QMainWindow):
self._myControl.saveMergedScan(sfilename, mergeindex=self._lastMergeIndex)
- return
-
def doSaveMultipleScans(self):
""" Save multiple scans
"""
@@ -1461,14 +1381,11 @@ class MainWindow(QtGui.QMainWindow):
# Get base file name
homedir = os.getcwd()
- savedir = str(QtGui.QFileDialog.getExistingDirectory(self,'Get Directory To Save Fullprof',homedir))
+ savedir = str(QtGui.QFileDialog.getExistingDirectory(self, 'Get Directory To Save Fullprof', homedir))
for scanno in scanslist:
- sfilename = os.path.join(savedir, "HB2A_Exp%d_Scan%d_FP.dat"%(expno, scanno))
+ sfilename = os.path.join(savedir, "HB2A_Exp%d_Scan%d_FP.dat" % (expno, scanno))
self._myControl.savePDFile(expno, scanno, 'fullprof', sfilename)
- # ENDFOR
-
- return
def doSaveVanRun(self):
""" Save the vanadium run with peaks removed
@@ -1487,8 +1404,6 @@ class MainWindow(QtGui.QMainWindow):
self._myControl.saveProcessedVanadium(expno, scanno, sfilename)
- return
-
def doSmoothVanadiumData(self):
""" Smooth vanadium spectrum
"""
@@ -1503,7 +1418,7 @@ class MainWindow(QtGui.QMainWindow):
smoothparams_str = str(self.ui.lineEdit_smoothParams.text())
# Smooth data
status = self._myControl.smoothVanadiumSpectrum(expno, scanno, smoothparams_str)
- if status is False:
+ if not status:
self._logError("Failed to smooth vanadium data")
# Plot
@@ -1512,8 +1427,6 @@ class MainWindow(QtGui.QMainWindow):
label = "Vanadium Exp %d Scan %d FFT-Smooth by %s" % (expno, scanno, smoothparams_str)
self._plotVanadiumRun(expno, scanno, xlabel, label, False, True)
- return
-
def doSmoothVanadiumApply(self):
""" Apply smoothing effect to vanadium data
"""
@@ -1527,8 +1440,6 @@ class MainWindow(QtGui.QMainWindow):
self._myControl.applySmoothVanadium(expno, scanno, True)
- return
-
def doSmoothVanadiumUndo(self):
""" Undo smoothing vanadium
"""
@@ -1541,8 +1452,6 @@ class MainWindow(QtGui.QMainWindow):
self._myControl.applySmoothVanadium(expno, scanno, False)
- return
-
def doStripVandiumPeaks(self):
""" Strip vanadium peaks
"""
@@ -1559,21 +1468,19 @@ class MainWindow(QtGui.QMainWindow):
# Get and build binning parameter
xmin, binsize, xmax = self._uiGetBinningParams(itab=4)
if xmin is None:
- binparams = '%f'%(binsize)
+ binparams = '%f' % (binsize)
else:
- binparams = '%f,%f,%f'%(xmin, binsize, xmax)
+ binparams = '%f,%f,%f' % (xmin, binsize, xmax)
# Strip vanadium peak
good = self._myControl.stripVanadiumPeaks(expno, scanno, binparams, vanpeakposlist=None)
# Plot
- if good is True:
+ if good:
xlabel = self._getXLabelFromUnit(unit)
- label="Exp %d Scan %d Bin = %.5f Vanadium Stripped" % (expno, scanno, binsize)
+ label = "Exp %d Scan %d Bin = %.5f Vanadium Stripped" % (expno, scanno, binsize)
self._plotVanadiumRun(expno, scanno, xlabel, label, False)
- return
-
def doUpdateWavelength(self):
""" Update the wavelength to line edit
"""
@@ -1592,8 +1499,6 @@ class MainWindow(QtGui.QMainWindow):
self.ui.lineEdit_wavelength.setText(str(wavelength))
- return
-
def on_mouseDownEvent(self, event):
""" Respond to pick up a value with mouse down event
Definition of button_press_event is:
@@ -1634,9 +1539,6 @@ class MainWindow(QtGui.QMainWindow):
# add other required actions
menu.popup(QtGui.QCursor.pos())
- # ENDIF
-
- return
def on_mouseMotion(self, event):
""" Event handler for mouse being detected to move
@@ -1652,30 +1554,21 @@ class MainWindow(QtGui.QMainWindow):
self._viewMerge_X = event.xdata
self._viewMerge_Y = event.ydata
- #if prey is None or int(prey) != int(self._viewMerge_Y):
- # print "Mouse is moving to ", event.xdata, event.ydata
-
- return
-
def addSomething(self):
"""
"""
# FUTURE - Need to implement how to deal with this
print("Add scan back to merge")
- return
-
def rmSomething(self):
"""
"""
# FUTURE - Need to implement how to deal with this
print("Remove a scan from merged data.")
- return
-
- #--------------------------------------------------------------------------
+ # --------------------------------------------------------------------------
# Private methods to plot data
- #--------------------------------------------------------------------------
+ # --------------------------------------------------------------------------
def _plotIndividualDetCountsVsSampleLog(self, expno, scanno, detid, samplename, raw=True):
""" Plot one specific detector's counts vs. one specified sample log's value
along with all Pts.
@@ -1711,11 +1604,9 @@ class MainWindow(QtGui.QMainWindow):
color=color,
x_label=samplename,
y_label='Counts',
- label='DetID = %d'%(detid))
+ label='DetID = %d' % (detid))
# FUTURE: In future, need to find out how to use self._graphIndDevMode
- # self._graphIndDevMode = (samplename, 'Counts')
- return
def _plot_individual_detector_counts(self, expno, scanno, detid, xaxis, resetboundary=False):
""" Plot a specific detector's counts along all experiment points (pt)
@@ -1741,17 +1632,17 @@ class MainWindow(QtGui.QMainWindow):
# Canvas and line information
canvas = self.ui.graphicsView_indvDet
- if (canvas in self._tabLineDict) is False:
+ if canvas not in self._tabLineDict:
self._tabLineDict[canvas] = []
# get data
- self._logNotice("Input x-axis is '%s' for plotting individual detector's counts."%(xaxis))
+ self._logNotice("Input x-axis is '%s' for plotting individual detector's counts." % (xaxis))
if len(xaxis) == 0:
xaxis = None
vecx, vecy = self._myControl.getIndividualDetCounts(expno, scanno, detid, xaxis, plot_normal)
- if isinstance(vecx, numpy.ndarray) is False:
+ if not isinstance(vecx, numpy.ndarray):
raise NotImplementedError('vecx, vecy must be numpy arrays.')
- if plot_error_bar is True:
+ if plot_error_bar:
y_err = numpy.sqrt(vecy)
else:
y_err = None
@@ -1761,7 +1652,6 @@ class MainWindow(QtGui.QMainWindow):
if xaxis == "" or xaxis == "2theta/Scattering Angle":
xlabel = r'$2\theta$'
else:
- #xlabel = "Pt."
xlabel = xaxis
# FUTURE - If it works with any way of plotting, then refactor Pt. with any other sample names
@@ -1772,24 +1662,22 @@ class MainWindow(QtGui.QMainWindow):
y_label='Counts', label=label, y_err=y_err)
self._tabLineDict[canvas].append((expno, scanno, detid))
- if resetboundary is True:
+ if resetboundary:
# Set xmin and xmax about the data for first time
xmin = min(vecx)
xmax = max(vecx)
ymin = min(vecy)
ymax = max(vecy)
- resetboundary = False
else:
# auto setup for image boundary
xmin = min(min(vecx), canvas.getXLimit()[0])
xmax = max(max(vecx), canvas.getXLimit()[1])
ymin = min(min(vecy), canvas.getYLimit()[0])
ymax = max(max(vecy), canvas.getYLimit()[1])
- # ENDIFELSE
- dx = xmax-xmin
- dy = ymax-ymin
- canvas.setXYLimit(xmin-dx*0.0001, xmax+dx*0.0001, ymin-dy*0.0001, ymax+dy*0.0001)
+ dx = xmax - xmin
+ dy = ymax - ymin
+ canvas.setXYLimit(xmin - dx * 0.0001, xmax + dx * 0.0001, ymin - dy * 0.0001, ymax + dy * 0.0001)
# Set canvas mode
# FUTURE: Consider how to use self._graphIndDevMode in future
@@ -1810,9 +1698,6 @@ class MainWindow(QtGui.QMainWindow):
vecx = numpy.array([pos, pos])
vecy = numpy.array([rangey[0], rangey[1]])
canvas.add_plot1d(vecx, vecy, color='black', line_style='--')
- # ENDFOR
-
- return
def _plotRawDetSignal(self, expno, scanno, plotmode, ptno, dooverplot):
""" Plot the counts of all detectors of a certain Pt. in an experiment
@@ -1823,11 +1708,11 @@ class MainWindow(QtGui.QMainWindow):
# Set up canvas and dictionary
canvas = self.ui.graphicsView_Raw
- if (canvas in self._tabLineDict) is False:
+ if canvas not in self._tabLineDict:
self._tabLineDict[canvas] = []
# Check whether data exists
- if self._myControl.hasDataLoaded(expno, scanno) is False:
+ if not self._myControl.hasDataLoaded(expno, scanno):
self._logError("File has not been loaded for Exp %d Scan %d. Load data first!" % (expno, scanno))
return
@@ -1845,7 +1730,7 @@ class MainWindow(QtGui.QMainWindow):
# Plot plot
ptno = int(ptno)
- if dooverplot is False:
+ if not dooverplot:
self.ui.graphicsView_Raw.clearAllLines()
self.ui.graphicsView_Raw.setLineMarkerColorIndex(0)
self._tabLineDict[canvas] = []
@@ -1870,28 +1755,27 @@ class MainWindow(QtGui.QMainWindow):
label = 'Pt %d' % (ptno)
# skip if this plot has existed
- if self._tabLineDict[canvas].count( (expno, scanno, ptno) ) == 1:
+ if self._tabLineDict[canvas].count((expno, scanno, ptno)) == 1:
continue
marker, color = canvas.getNextLineMarkerColorCombo()
canvas.add_plot1d(vecx, vecy, marker=marker, color=color, x_label=unit,
- y_label='intensity',label=label)
+ y_label='intensity', label=label)
# set up line tuple
- self._tabLineDict[canvas].append( (expno, scanno, ptno) )
+ self._tabLineDict[canvas].append((expno, scanno, ptno))
# auto setup for image boundary
xmin = min(min(vecx), canvas.getXLimit()[0])
xmax = max(max(vecx), canvas.getXLimit()[1])
ymin = min(min(vecy), canvas.getYLimit()[0])
ymax = max(max(vecy), canvas.getYLimit()[1])
- # ENDFOR
# Reset canvas x-y limit
if xmin is not None:
- dx = xmax-xmin
- dy = ymax-ymin
- canvas.setXYLimit(xmin-dx*0.0001, xmax+dx*0.0001, ymin-dy*0.0001, ymax+dy*0.0001)
+ dx = xmax - xmin
+ dy = ymax - ymin
+ canvas.setXYLimit(xmin - dx * 0.0001, xmax + dx * 0.0001, ymin - dy * 0.0001, ymax + dy * 0.0001)
return True
@@ -1916,45 +1800,43 @@ class MainWindow(QtGui.QMainWindow):
xlabel = self._getXLabelFromUnit(self.ui.comboBox_mscanUnit.currentText())
canvas.add_plot1d(vecx, vecy, marker=marker, color=color,
- x_label=xlabel, y_label='intensity',label=label)
+ x_label=xlabel, y_label='intensity', label=label)
xmax = max(vecx)
xmin = min(vecx)
- dx = xmax-xmin
+ dx = xmax - xmin
ymax = max(vecy)
ymin = min(vecy)
- dy = ymax-ymin
+ dy = ymax - ymin
- canvas.setXYLimit(xmin-dx*0.1, xmax+dx*0.1, ymin-dy*0.1, ymax+dy*0.1)
-
- return
+ canvas.setXYLimit(xmin - dx * 0.1, xmax + dx * 0.1, ymin - dy * 0.1, ymax + dy * 0.1)
def _plotReducedData(self, exp, scan, canvas, xlabel, label=None, clearcanvas=True,
spectrum=0, plot_error=False):
""" Plot reduced data for exp and scan
"""
if spectrum != 0:
- raise NotImplementedError("Unable to support spectrum = %d case."%(spectrum))
+ raise NotImplementedError("Unable to support spectrum = %d case." % (spectrum))
# whether the data is load
- if self._myControl.hasReducedWS(exp, scan) is False:
+ if not self._myControl.hasReducedWS(exp, scan):
self._logWarning("No data to plot!")
return
# get to know whether it is required to clear the image
- if clearcanvas is True:
+ if clearcanvas:
canvas.clearAllLines()
canvas.setLineMarkerColorIndex(0)
# plot
vec_x, vec_y = self._myControl.getVectorToPlot(exp, scan)
- if isinstance(vec_x, numpy.ndarray) is False:
+ if not isinstance(vec_x, numpy.ndarray):
vec_x = numpy.array(vec_x)
vec_y = numpy.array(vec_y)
# FUTURE - Should check y_err set up correctly in Mantid or not
- if plot_error is True:
+ if plot_error:
raise RuntimeError('Implement how to return y_err ASAP.')
else:
y_err = None
@@ -1967,21 +1849,19 @@ class MainWindow(QtGui.QMainWindow):
label = "Exp %d Scan %d" % (exp, scan)
canvas.add_plot1d(vec_x, vec_y, marker=marker, color=color,
- x_label=xlabel, y_label='intensity',label=label,
+ x_label=xlabel, y_label='intensity', label=label,
y_err=y_err)
- if clearcanvas is True:
+ if clearcanvas:
xmax = max(vec_x)
xmin = min(vec_x)
- dx = xmax-xmin
+ dx = xmax - xmin
ymax = max(vec_y)
ymin = min(vec_y)
- dy = ymax-ymin
-
- canvas.setXYLimit(xmin-dx*0.1, xmax+dx*0.1, ymin-dy*0.1, ymax+dy*0.1)
+ dy = ymax - ymin
- return
+ canvas.setXYLimit(xmin - dx * 0.1, xmax + dx * 0.1, ymin - dy * 0.1, ymax + dy * 0.1)
def _plotSampleLog(self, expno, scanno, samplelogname):
""" Plot the value of a sample log among all Pt.
@@ -1992,7 +1872,7 @@ class MainWindow(QtGui.QMainWindow):
samplelogname = str(samplelogname)
# Reject if data is not loaded
- if self._myControl.hasDataLoaded(expno, scanno) is False:
+ if not self._myControl.hasDataLoaded(expno, scanno):
self._logError("Data file for Exp %d Scan %d has not been loaded." % (expno, scanno))
return False
@@ -2008,7 +1888,7 @@ class MainWindow(QtGui.QMainWindow):
self.ui.comboBox_indvDetXLabel.addItems(floatsamplelognamelist)
raise RuntimeError("This X-label combo box should be set up during loading data before.")
- xlabel=str(self.ui.comboBox_indvDetXLabel.currentText())
+ xlabel = str(self.ui.comboBox_indvDetXLabel.currentText())
# get data
vecx, vecy = self._myControl.getSampleLogValue(expno, scanno, samplelogname, xlabel)
@@ -2026,7 +1906,7 @@ class MainWindow(QtGui.QMainWindow):
label = samplelogname
canvas.add_plot1d(vecx, vecy, marker=marker, color=color, x_label=xlabel,
- y_label='Counts',label=label)
+ y_label='Counts', label=label)
# auto setup for image boundary
xmin = min(vecx)
@@ -2034,9 +1914,9 @@ class MainWindow(QtGui.QMainWindow):
ymin = min(vecy)
ymax = max(vecy)
- dx = xmax-xmin
- dy = ymax-ymin
- canvas.setXYLimit(xmin-dx*0.0001, xmax+dx*0.0001, ymin-dy*0.0001, ymax+dy*0.0001)
+ dx = xmax - xmin
+ dy = ymax - ymin
+ canvas.setXYLimit(xmin - dx * 0.0001, xmax + dx * 0.0001, ymin - dy * 0.0001, ymax + dy * 0.0001)
return True
@@ -2050,14 +1930,14 @@ class MainWindow(QtGui.QMainWindow):
exp = int(exp)
scan = int(scan)
- if self._myControl.hasReducedWS(exp, scan) is False:
+ if not self._myControl.hasReducedWS(exp, scan):
self._logWarning("No data to plot!")
return
# Get data to plot
try:
vecx, vecy = self._myControl.getVectorProcessVanToPlot(exp, scan, TempData)
- if TempData is False:
+ if not TempData:
vecx, vecyOrig = self._myControl.getVectorToPlot(exp, scan)
diffY = vecyOrig - vecy
except NotImplementedError as e:
@@ -2069,14 +1949,14 @@ class MainWindow(QtGui.QMainWindow):
# Get to know whether it is required to clear the image
canvas = self.ui.graphicsView_vanPeaks
- if TempData is True:
+ if TempData:
clearcanvas = False
- if clearcanvas is True:
+ if clearcanvas:
canvas.clearAllLines()
canvas.setLineMarkerColorIndex(0)
# get the marker color for the line
- if TempData is True:
+ if TempData:
marker = None
color = 'blue'
else:
@@ -2084,26 +1964,23 @@ class MainWindow(QtGui.QMainWindow):
# plot
canvas.add_plot1d(vecx, vecy, marker=marker, color=color,
- x_label=xlabel, y_label='intensity',label=label)
+ x_label=xlabel, y_label='intensity', label=label)
- if TempData is False:
+ if not TempData:
canvas.add_plot1d(vecx, diffY, marker='+', color='green',
- x_label=xlabel, y_label='intensity',label='Diff')
+ x_label=xlabel, y_label='intensity', label='Diff')
# reset canvas limits
- if clearcanvas is True:
+ if clearcanvas:
xmax = max(vecx)
xmin = min(vecx)
- dx = xmax-xmin
+ dx = xmax - xmin
ymax = max(vecy)
ymin = min(diffY)
- dy = ymax-ymin
-
- canvas.setXYLimit(xmin-dx*0.1, xmax+dx*0.1, ymin-dy*0.1, ymax+dy*0.1)
- # ENDIF
+ dy = ymax - ymin
- return
+ canvas.setXYLimit(xmin - dx * 0.1, xmax + dx * 0.1, ymin - dy * 0.1, ymax + dy * 0.1)
def _uiDownloadDataFile(self, exp, scan):
""" Download data file according to its exp and scan
@@ -2115,49 +1992,47 @@ class MainWindow(QtGui.QMainWindow):
uselocal = self.ui.radioButton_useLocal.isChecked()
if useserver == uselocal:
self._logError("It is logically wrong to set up server/local dir for data.")
- useserver = True
- uselocal = False
self.ui.radioButton_useServer.setChecked(True)
self.ui.radioButton_useLocal.setChecked(False)
- # ENDIF
rvalue = False
- if self._srcFromServer is True:
+ if self._srcFromServer:
# Use server: build the URl to download data
- if self._serverAddress.endswith('/') is False:
+ if not self._serverAddress.endswith('/'):
self._serverAddress += '/'
fullurl = "%s%s/exp%d/Datafiles/%s_exp%04d_scan%04d.dat" % (self._serverAddress,
- self._instrument.lower(), exp, self._instrument.upper(), exp, scan)
+ self._instrument.lower(), exp,
+ self._instrument.upper(), exp, scan)
print("URL: ", fullurl)
cachedir = str(self.ui.lineEdit_cache.text()).strip()
- if os.path.exists(cachedir) is False:
+ if not os.path.exists(cachedir):
invalidcache = cachedir
cachedir = os.getcwd()
self.ui.lineEdit_cache.setText(cachedir)
self._logWarning("Cache directory %s is not valid. "
- "Using current workspace directory %s as cache." % (invalidcache, cachedir) )
+ "Using current workspace directory %s as cache." % (invalidcache, cachedir))
filename = '%s_exp%04d_scan%04d.dat' % (self._instrument.upper(), exp, scan)
srcFileName = os.path.join(cachedir, filename)
status, errmsg = urllib.downloadFile(fullurl, srcFileName)
- if status is False:
+ if not status:
self._logError(errmsg)
srcFileName = None
else:
rvalue = True
- elif self._srcAtLocal is True:
+ elif self._srcAtLocal:
# Data from local
srcFileName = os.path.join(self._localSrcDataDir, "%s/Exp%d_Scan%04d.dat" % (self._instrument, exp, scan))
- if os.path.exists(srcFileName) is True:
+ if os.path.exists(srcFileName):
rvalue = True
else:
raise NotImplementedError("Logic error. Neither downloaded from server.\
Nor from local drive")
- return (rvalue,srcFileName)
+ return (rvalue, srcFileName)
def _uiGetBinningParams(self, itab):
""" Get binning parameters
@@ -2179,7 +2054,7 @@ class MainWindow(QtGui.QMainWindow):
xmax = str(self.ui.lineEdit_max2Theta.text())
binsize = str(self.ui.lineEdit_binsize2Theta.text())
else:
- raise NotImplementedError("Binning parameters are not used for %d-th tab."%(itab))
+ raise NotImplementedError("Binning parameters are not used for %d-th tab." % (itab))
# Parse values
try:
@@ -2219,8 +2094,6 @@ class MainWindow(QtGui.QMainWindow):
self._logError("Extra scans are not a list of integers: %s." % (
str(self.ui.lineEdit_extraScans.text())))
excludedetidlist = []
- # ENDIF
- # ENDIF
return excludedetidlist
@@ -2251,16 +2124,16 @@ class MainWindow(QtGui.QMainWindow):
# scans = [startscan, endscan] + [others] - [excluded]
status, extrascanlist = self._getIntArray(str(self.ui.lineEdit_extraScans.text()))
- if status is False:
+ if not status:
raise RuntimeError(extrascanlist)
status, excludedlist = self._getIntArray(str(self.ui.lineEdit_exclScans.text()))
- self._logDebug("Excluded list: %s" %(str(excludedlist)))
- if status is False:
+ self._logDebug("Excluded list: %s" % (str(excludedlist)))
+ if not status:
self._logError(excludedlist)
return
- scanslist = list(range(startscan, endscan+1))
+ scanslist = list(range(startscan, endscan + 1))
scanslist.extend(extrascanlist)
scanslist = list(set(scanslist))
for scan in excludedlist:
@@ -2272,7 +2145,7 @@ class MainWindow(QtGui.QMainWindow):
""" Check whether current bin parameters are same
as given value
"""
- xmin,binsize,xmax = self._uiGetBinningParams(itab)
+ xmin, binsize, xmax = self._uiGetBinningParams(itab)
newbinparams = [xmin, binsize, xmax]
# check binning
@@ -2282,22 +2155,21 @@ class MainWindow(QtGui.QMainWindow):
par_1 = newbinparams[i]
try:
- if abs(float(par_0)-float(par_1)) > 1.0E-6:
+ if abs(float(par_0) - float(par_1)) > 1.0E-6:
same = False
except TypeError:
if par_0 is not None or par_1 is not None:
same = False
- if same is False:
+ if not same:
break
- # ENDFOR
change = not same
- if change is True:
+ if change:
print("[D...............B]", end=' ')
- print("%s vs %s " % (str(xmin), str(self._tabBinParamDict[itab][0])), end=' ')
- print("%s vs %s " % (str(xmax), str(self._tabBinParamDict[itab][2])), end=' ')
- print("%s vs %s " % (str(binsize), str(self._tabBinParamDict[itab][1])))
+ print("%s vs %s " % (str(xmin), str(self._tabBinParamDict[itab][0])), end=' ')
+ print("%s vs %s " % (str(xmax), str(self._tabBinParamDict[itab][2])), end=' ')
+ print("%s vs %s " % (str(binsize), str(self._tabBinParamDict[itab][1])))
else:
print("[DB] Rebin = False")
@@ -2320,7 +2192,6 @@ class MainWindow(QtGui.QMainWindow):
except NotImplementedError as e:
self._logError(str(e))
return
- # ENDIF
# Get binning parameter
xmin, binsize, xmax = self._uiGetBinningParams(itab)
@@ -2333,7 +2204,7 @@ class MainWindow(QtGui.QMainWindow):
wavelength = float(str(self.ui.lineEdit_wavelength.text()))
except TypeError:
if unit != '2theta':
- raise NotImplementedError('Wavelength must be specified for unit %s.'%(unit))
+ raise NotImplementedError('Wavelength must be specified for unit %s.' % (unit))
# Get scale factor
try:
@@ -2341,7 +2212,7 @@ class MainWindow(QtGui.QMainWindow):
except EmptyError:
scalefactor = None
except ValueError as valueerror:
- raise ValueError("Unable to get normalization factor due to %s."%(str(valueerror)))
+ raise ValueError("Unable to get normalization factor due to %s." % (str(valueerror)))
# Rebin
try:
@@ -2367,8 +2238,7 @@ class MainWindow(QtGui.QMainWindow):
change = self._uiIsBinParamsChange(itab, self._tabBinParamDict[itab])
# check whether line record
- if unit == self._currUnit and \
- self._tabLineDict[itab].count((expno, scanno)) > 0 and change is False:
+ if unit == self._currUnit and self._tabLineDict[itab].count((expno, scanno)) > 0 and not change:
# there is no need to plot again as line exists
return
@@ -2379,32 +2249,30 @@ class MainWindow(QtGui.QMainWindow):
scanno = r[2]
# failed to reduce
- if good is False:
+ if not good:
self._logError("Failed to reduce Exp %d Scan %d" % (expno, scanno))
return
# clear canvas???
if unit != self._currUnit:
clearcanvas = True
- elif self.ui.checkBox_clearPrevious.isChecked() is False:
+ elif not self.ui.checkBox_clearPrevious.isChecked():
# NOTE: naming of the widget is VERY confusing. Should be changed to keepPrevious
clearcanvas = True
else:
clearcanvas = False
# reset record dictionary if unit is different from present
- if clearcanvas is True:
+ if clearcanvas:
self._tabLineDict[itab] = []
self._currUnit = unit
self._tabLineDict[itab].append((expno, scanno))
xlabel = self._getXLabelFromUnit(unit)
- label = "Exp %s Scan %s"%(str(expno), str(scanno))
+ label = "Exp %s Scan %s" % (str(expno), str(scanno))
self._plotReducedData(expno, scanno, canvas, xlabel, label=label, clearcanvas=clearcanvas)
- return
-
def _logDebug(self, dbinfo):
""" Log debug information
"""
@@ -2428,8 +2296,6 @@ class MainWindow(QtGui.QMainWindow):
msg = "[Warning]: %s" % (warning_info)
QtGui.QMessageBox.information(self, "OK!", msg)
- return
-
def _getFloat(self, lineedit):
""" Get integer from line edit
Exception: ValueError if empty or no input
@@ -2489,7 +2355,7 @@ class MainWindow(QtGui.QMainWindow):
intvalue = int(valuestr)
if str(intvalue) != valuestr:
returnstatus = False
- errmsg = "Contains non-integer string %s." % (valuestr)
+ errmsg = "Contains non-integer string %s." % (valuestr)
except ValueError:
returnstatus = False
errmsg = "String %s is not an integer." % (valuestr)
@@ -2514,24 +2380,21 @@ class MainWindow(QtGui.QMainWindow):
templist.append(intvalue)
# break loop
- if returnstatus is False:
+ if not returnstatus:
break
- # ENDFOR
- intlist.extend(range(templist[0], templist[1]+1))
+ intlist.extend(range(templist[0], templist[1] + 1))
else:
# Undefined siutation
returnstatus = False
errmsg = "Term %s contains more than 1 dash." % (level0term)
- # ENDIFELSE
# break loop if something is wrong
- if returnstatus is False:
+ if not returnstatus:
break
- # ENDFOR
# Return with false
- if returnstatus is False:
+ if not returnstatus:
return (False, errmsg)
return (True, intlist)
diff --git a/scripts/LargeScaleStructures/data_stitching.py b/scripts/LargeScaleStructures/data_stitching.py
index 25f15353e83ebc592ccd8ec5a6b43731e7437979..26dc749e8a4a83773b16ea40fff9d5e58d9a7d02 100644
--- a/scripts/LargeScaleStructures/data_stitching.py
+++ b/scripts/LargeScaleStructures/data_stitching.py
@@ -563,6 +563,55 @@ class Stitcher(object):
return ws_combined
+def _check_all_or_no_q_values(q_min, q_max):
+ if (q_min is None) != (q_max is None):
+ error_msg = "Both q_min and q_max parameters should be provided, not just one"
+ Logger("data_stitching").error(error_msg)
+ raise RuntimeError(error_msg)
+
+
+def _check_data_list(data_list, scale):
+ if not isinstance(data_list, list):
+ error_msg = "The data_list parameter should be a list"
+ Logger("data_stitching").error(error_msg)
+ raise RuntimeError(error_msg)
+
+ if len(data_list) < 2:
+ error_msg = "The data_list parameter should contain at least two data sets"
+ Logger("data_stitching").error(error_msg)
+ raise RuntimeError(error_msg)
+
+ if isinstance(scale, list) and len(scale) != len(data_list):
+ error_msg = "If the scale parameter is provided as a list, it should have the same length as data_list"
+ Logger("data_stitching").error(error_msg)
+ raise RuntimeError(error_msg)
+
+
+def _validate_q_value(q, n_data_sets, which_q):
+ if type(q) in [int, float]:
+ q = [q]
+
+ if not isinstance(q, list):
+ error_msg = "The q_{0} parameter must be a list".format(which_q)
+ Logger("data_stitching").error(error_msg)
+ raise RuntimeError(error_msg)
+
+ if len(q) != n_data_sets - 1:
+ error_msg = "The length of q_{0} must be 1 shorter than the length of data_list: q_{1}={2}".format(which_q,
+ which_q, q)
+ Logger("data_stitching").error(error_msg)
+ raise RuntimeError(error_msg)
+
+ for i in range(n_data_sets - 1):
+ try:
+ eq[i] = float(q[i])
+ except:
+ error_msg = "The Q range parameters are invalid: q_{0}={1}".format(which_q, q)
+ Logger("data_stitching").error(error_msg)
+ raise RuntimeError(error_msg)
+ return q
+
+
def stitch(data_list=[], q_min=None, q_max=None, output_workspace=None,
scale=None, save_output=False):
"""
@@ -576,65 +625,19 @@ def stitch(data_list=[], q_min=None, q_max=None, output_workspace=None,
# Sanity check: q_min and q_max can either both be None or both be
# of length N-1 where N is the length of data_list
- if (q_min is not None and q_max is None) or \
- (q_max is not None and q_min is None):
- error_msg = "Both q_min and q_max parameters should be provided, not just one"
- Logger("data_stitching").error(error_msg)
- raise RuntimeError(error_msg)
-
- if not isinstance(data_list, list):
- error_msg = "The data_list parameter should be a list"
- Logger("data_stitching").error(error_msg)
- raise RuntimeError(error_msg)
+ _check_all_or_no_q_values(q_min, q_max)
+ _check_data_list(data_list, scale)
n_data_sets = len(data_list)
- if n_data_sets < 2:
- error_msg = "The data_list parameter should contain at least two data sets"
- Logger("data_stitching").error(error_msg)
- raise RuntimeError(error_msg)
-
# Check whether we just need to scale the data sets using the provided
# scaling factors
- has_scale_factors = False
- if isinstance(scale, list):
- if len(scale) == n_data_sets:
- has_scale_factors = True
- else:
- error_msg = "If the scale parameter is provided as a list, it should have the same length as data_list"
- Logger("data_stitching").error(error_msg)
- raise RuntimeError(error_msg)
+ has_scale_factors = isinstance(scale, list) and len(scale) == n_data_sets
is_q_range_limited = False
if q_min is not None and q_max is not None:
is_q_range_limited = True
- if type(q_min) in [int, float]:
- q_min = [q_min]
- if type(q_max) in [int, float]:
- q_max = [q_max]
-
- if not isinstance(q_min, list) or not isinstance(q_max, list):
- error_msg = "The q_min and q_max parameters must be lists"
- Logger("data_stitching").error(error_msg)
- raise RuntimeError(error_msg)
-
- if not len(q_min) == n_data_sets-1:
- error_msg = "The length of q_min must be 1 shorter than the length of data_list: q_min=%s" % str(q_min)
- Logger("data_stitching").error(error_msg)
- raise RuntimeError(error_msg)
- if not len(q_max) == n_data_sets-1:
- error_msg = "The length of q_max must be 1 shorter than the length of data_list: q_max=%s" % str(q_max)
- Logger("data_stitching").error(error_msg)
- raise RuntimeError(error_msg)
-
- # Sanity check
- for i in range(n_data_sets-1):
- try:
- q_min[i] = float(q_min[i])
- q_max[i] = float(q_max[i])
- except:
- error_msg = "The Q range parameters are invalid: q_min=%s q_max=%s" % (str(q_min), str(q_max))
- Logger("data_stitching").error(error_msg)
- raise RuntimeError(error_msg)
+ q_min = _validate_q_value(q_min, n_data_sets, "min")
+ q_max = _validate_q_value(q_max, n_data_sets, "max")
else:
q_min = (n_data_sets-1)*[None]
q_max = (n_data_sets-1)*[None]
diff --git a/tools/reports/facility-code-changes.py b/tools/reports/facility-code-changes.py
index b29ba55d91b5bb720551031e9697cc2f9f33430e..a75ce60f8ec3118dbab3ac923c6f134bdd73b7fc 100644
--- a/tools/reports/facility-code-changes.py
+++ b/tools/reports/facility-code-changes.py
@@ -64,6 +64,24 @@ def generate_commit_data(year_start, year_end):
f.close()
+def _ensure_is_directory(filepath):
+ if not os.path.isdir(filepath):
+ print("ERROR: Specified repository location is not a directory.")
+ exit()
+
+
+def _assign_change_to_facility(domains, changes, year, facility_dict, date_key, increment):
+ found = False
+ for domain in domains.keys():
+ if domain in changes:
+ # ORNL didn't join until 2009
+ if domains[domain] == 'ORNL' and int(year) < 2009:
+ domain = 'stfc.ac.uk'
+ facility_dict[date_key][domains[domain]] != increment
+ found = True
+ return found, facility_dict
+
+
if __name__ == '__main__':
print("Generating some random metrics...\n")
@@ -80,13 +98,10 @@ if __name__ == '__main__':
args = parser.parse_args()
repolocation = args.repository
- if not os.path.isdir(repolocation):
- print("ERROR: Specified repository location is not a directory.")
- exit()
+ _ensure_is_directory(repolocation)
organisations = ['STFC', 'ORNL', 'ESS', 'ILL', 'PSI', 'ANSTO', 'KITWARE', 'JUELICH', 'OTHERS']
- domains = {}
domains = {'stfc.ac.uk': 'STFC',
'clrc.ac.uk': 'STFC',
'tessella.com': 'STFC',
@@ -140,9 +155,7 @@ if __name__ == '__main__':
csvadded = open('facility-added-lines.csv', 'w')
csvremoved = open('facility-removed-lines.csv', 'w')
- field_names = ['date']
- for org in organisations:
- field_names.append(org)
+ field_names = ['date'] + organisations
commits_writer = csv.DictWriter(csvcommits, fieldnames=field_names)
commits_writer.writeheader()
@@ -174,9 +187,8 @@ if __name__ == '__main__':
email_changes = ''
email_commits = ''
# Don't go past the current month
- if current_year == year:
- if month > current_month:
- continue
+ if current_year == year and month > current_month:
+ continue
print("Getting stats for {0}-{1:02d}".format(str(year), month))
since = "--since='{0}-{1}-1'".format(str(year), str(month))
@@ -204,15 +216,10 @@ if __name__ == '__main__':
removed = 0
# Is the line blank (or None)
- if line is None or len(line) is 0:
- # print("BLANK:'{0}'".format(str(line)))
- continue
- if len(line.strip().replace('\n', '')) == 0:
+ if line is None or len(line.strip().replace("\n", "")) == 0:
# print("BLANK:'{0}'".format(str(line)))
continue
- # print(line)
-
# Is the line an email address ?
if "@" in line:
email_changes = line.strip()
@@ -223,28 +230,26 @@ if __name__ == '__main__':
if 'files changed' in item:
changed = item.strip().split(' ')[0]
# print("FILES CHANGED:{0}".format(changed))
- if 'insertions(+)' in item:
+ elif 'insertions(+)' in item:
added = item.strip().split(' ')[0]
# print ("INSERTIONS:{0}".format(added))
- if 'deletions(-)' in item:
+ elif 'deletions(-)' in item:
removed = item.strip().split(' ')[0]
# print ("DELETIONS:{0}".format(removed))
- found = False
- # Assign each to a facility
- for domain in domains.keys():
- if domain in email_changes:
- # ORNL didn't join until 2009
- if domains[domain] == 'ORNL' and int(year) < 2009:
- domain = 'stfc.ac.uk'
- facility_changed[date_key][domains[domain]] += int(changed)
- facility_added[date_key][domains[domain]] += int(added)
- facility_removed[date_key][domains[domain]] += int(removed)
- found = True
- # print("FILES CHANGED:{0} ==> {1}".format(changed,domains[domain]))
- # print("FILES CHANGED:{0} ==> {1}".format(added,domains[domain]))
- # print("FILES CHANGED:{0} ==> {1}".format(removed,domains[domain]))
-
+ (facility_changed, found_changed) = _assign_change_to_facility(domains=domains, changes=email_changes,
+ year=year, date_key=date_key,
+ facility_dict=facility_changed,
+ increment=int(changed))
+ (facility_added, found_added) = _assign_change_to_facility(domains=domains, changes=email_changes,
+ year=year, date_key=date_key,
+ facility_dict=facility_added,
+ increment=int(added))
+ (facility_removed, found_removed) = _assign_change_to_facility(domains=domains, changes=email_changes,
+ year=year, date_key=date_key,
+ facility_dict=facility_removed,
+ increment=int(removed))
+ found = found_changed or found_added or found_removed
# Print out the email address if it didn't match anything
if not found:
print("Email ({0}) couldn't be matched to a facility!".format(str(email_changes)))
@@ -256,18 +261,10 @@ if __name__ == '__main__':
f2reading = open('facility-commits-{0}.stdout'.format(date_key), 'r', buffering=0)
for line in f2reading:
- found = False
email_commits = line.replace('"','').strip()
- found = False
- # Assign each to a facility
- for domain in domains.keys():
- if domain in email_commits:
- # ORNL didn't join until 2009
- if domains[domain] == 'ORNL' and int(year) < 2009:
- domain = 'stfc.ac.uk'
- facility_commits[date_key][domains[domain]] += 1
- found = True
-
+ (found, facility_commits) = _assign_change_to_facility(domains=domains, changes=email_commits,
+ year=year, facility_dict=facility_commits,
+ date_key=date_key, increment=1)
if not found:
print("Email for commits ({0}) couldn't be matched to a facility!".format(str(email_commits)))