← Previous Changeset
Next Changeset →

Changeset 6bd3a8d1 in sasview

Timestamp:

Mar 2, 2015 4:09:46 PM (9 years ago)

Author:

Doucet, Mathieu <doucetm@…>

Branches:

master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

Parents:

Message:

Remove extra white spaces

Location:

src/sas/calculator

Files:

: 4 edited

instrument.py (modified) (33 diffs)
kiessig_calculator.py (modified) (4 diffs)
resolution_calculator.py (modified) (78 diffs)
slit_length_calculator.py (modified) (7 diffs)

Legend:

: Unmodified
: Added
: Removed

src/sas/calculator/instrument.py

-                      r79492222
+                      r6bd3a8d1
     """
     def __init__(self):
         # assumes that all aligned at the centers
         # aperture_size [diameter] for pinhole, [dx, dy] for rectangular
 …
         self.source_size = _SOURCE_A_SIZE
         self.sample_distance = _SAMPLE_DISTANCE
     def set_source_size(self, size=[]):
         """
 …
             self.source_size = size
             validate(size[0])
     def set_sample_size(self, size=[]):
         """
 …
             self.sample_size = size
             validate(size[0])
     def set_sample_distance(self, distance=[]):
         """
 …
             self.sample_distance = distance
             validate(distance[0])
 class Sample(object):
     """
 …
     """
     def __init__(self):
         # assumes that all aligned at the centers
         # source2sample or sample2detector distance
 …
             self.sample_size = size
             validate(size[0])
     def set_thickness(self, thickness=0.0):
         """
 …
         self.thickness = thickness
         validate(thickness)
     def set_distance(self, distance=[]):
         """
 …
             if distance[0] != 0.0:
                 validate(distance[0])
 class Detector(object):
     """
 …
     """
     def __init__(self):
         # assumes that all aligned at the centers
         # source2sample or sample2detector distance
 …
         self.pix_size = _D_PIX_SIZE
     def set_size(self, size=[]):
         """
 …
             self.size = size
             validate(size[0])
     def set_pix_size(self, size=[]):
         """
 …
             self.pix_size = size
             validate(size[0])
     def set_distance(self, distance=[]):
         """
 …
             validate(distance[0])
 class Neutron(object):
     """
 …
     """
     def __init__(self):
         # neutron mass in cgs unit
         self.mass = _MASS
 …
         # default unit of the thickness
         self.wavelength_unit = 'A'
     def set_full_band(self):
         """
 …
         """
         self.band = self.spectrum
     def set_spectrum(self, spectrum):
         """
         Set spectrum
         :param spectrum: numpy array
         """
         self.spectrum = spectrum
         self.setup_spectrum()
     def setup_spectrum(self):
         """
 …
         # set default band
         self.set_band([self.min, self.max])
     def set_band(self, band=[]):
         """
         To set the wavelength band
         :param band: array of [min, max]
         """
 …
             raise
         self.band = band
     def set_intensity(self, intensity=368428):
         """
 …
         self.intensity = intensity
         validate(intensity)
     def set_wavelength(self, wavelength=_WAVE_LENGTH):
         """
 …
         self.mass = mass
         validate(mass)
     def set_wavelength_spread(self, spread=_WAVE_SPREAD):
         """
 …
         if spread != 0.0:
             validate(spread)
     def get_intensity(self):
         """
 …
         """
         return self.intensity
     def get_wavelength(self):
         """
 …
         """
         return self.mass
     def get_wavelength_spread(self):
         """
 …
         """
         return self.wavelength_spread
     def get_ramdom_value(self):
         """
 …
         """
         return self.wavelength
     def get_spectrum(self):
         """
 …
         """
         return self.spectrum
     def get_default_spectrum(self):
         """
 …
         """
         return numpy.array(_LAMBDA_ARRAY)
     def get_band(self):
         """
 …
         """
         return self.band
     def plot_spectrum(self):
         """
 …
         except:
             raise RuntimeError, "Can't import matplotlib required to plot..."
 class TOF(Neutron):
     """
 …
         self.wavelength_spread_list = [self.wavelength_spread]
         self.intensity_list = self.get_intensity_list()
     def get_intensity_list(self):
         """
 …
 .0)
         return out
     def get_wave_list(self):
         """
 …
         """
         return self.wavelength_list, self.wavelengthspread_list
     def set_wave_list(self, wavelength=[]):
         """
         Set wavelength list
         :param wavelength: list of wavelengths
         """
         self.wavelength_list = wavelength
     def set_wave_spread_list(self, wavelength_spread=[]):
         """
         Set wavelength_spread list
         :param wavelength_spread: list of wavelength spreads
         """
         self.wavelengthspread_list = wavelength_spread
 def validate(value=None):
     """
     Check if the value is folat > 0.0
     :return value: True / False
     """

src/sas/calculator/kiessig_calculator.py

-                      r79492222
+                      r6bd3a8d1
     """
     def __init__(self):
         # dq value
         self.deltaq = _DQ_DEFAULT
 …
         # unit of the thickness
         self.thickness_unit = 'A'
     def set_deltaq(self, dq=None):
         """
         Receive deltaQ value
         :param dq: q fringe width in 1/A unit
         """
         # set dq
         self.deltaq = dq
     def get_deltaq(self):
         """
 …
         """
         Calculate thickness.
         :return: the thickness.
         """
 …
             # return thickness value
             return thickness
     def get_thickness_unit(self):
         """

src/sas/calculator/resolution_calculator.py

-                      r79492222
+                      r6bd3a8d1
     """
     def __init__(self):
         # wavelength
         self.wave = Neutron()
 …
         self.qxrange = []
         self.qyrange = []
     def compute_and_plot(self, qx_value, qy_value, qx_min, qx_max,
                           qy_min, qy_max, coord='cartesian'):
 …
                             sigma_r, qx_min, qx_max, qy_min, qy_max,
                             coord, False)
-            # Non tof mode to be speed up
-            #if num_lamda < 2:
-            #    return self.plot_image(image)
             if qx_min > self.qx_min:
                 qx_min = self.qx_min
 …
             if qy_max < self.qy_max:
                 qy_max = self.qy_max
             # set max qranges
             self.qxrange = [qx_min, qx_max]
 …
             sigma1d += sigma1d_list[ind] * sigma1d_list[ind] * self.intensity
             total_intensity += self.intensity
         if total_intensity != 0:
             # average variance
 …
         else:
             self.image = image_out
         # plot image
         return self.plot_image(self.image)
     def setup_tof(self, wavelength, wavelength_spread):
         """
         Setup all parameters in instrument
         : param ind: index of lambda, etc
         """
 …
         self.set_wavelength_spread(wavelength_spread)
         self.intensity = self.wave.get_intensity()
         if wavelength == 0:
             msg = "Can't compute the resolution: the wavelength is zero..."
             raise RuntimeError, msg
         return self.intensity
     def compute(self, wavelength, wavelength_spread, qx_value, qy_value,
                 coord='cartesian', tof=False):
 …
         # sample to detector distance
         l_two = l_sad - l_sas
         # Sample offset correction for l_one and Lp on variance calculation
         l1_cor = (l_ssa * l_two) / (l_sas + l_two)
 …
         # normalize
         variance_1d_1 = knot * knot * variance_1d_1 / 12
         # for 2d
         #sigma_1 += sigma_wave_1
 …
         # normalize
         variance_1d_2 = knot * knot * variance_1d_2 / 12
         # for 2d
         #sigma_2 =  knot*sqrt(sigma_2/12)
 …
         self.sigma_1d = sigma1d
         return qr_value, phi, sigma_1, sigma_2, sigma_r, sigma1d
     def _within_detector_range(self, qx_value, qy_value):
         """
 …
             return False
         return True
     def get_image(self, qx_value, qy_value, sigma_1, sigma_2, sigma_r,
                   qx_min, qx_max, qy_min, qy_max,
 …
         # Get  qx_max and qy_max...
         self._get_detector_qxqy_pixels()
         qr_value, phi = self._get_polar_value(qx_value, qy_value)
 …
         if not full_cal:
             return None
         # Make an empty graph in the detector scale
         dx_size = (self.qx_max - self.qx_min) / (1000 - 1)
 …
             # qy_center
             qc_2 = qy_value
             # Calculate the 2D Gaussian distribution image
             image = self._gaussian2d(q_1, q_2, qc_1, qc_2,
 …
         else:
             self.image_lam = image * self.intensity
         return self.image_lam
     def plot_image(self, image):
         """
         Plot image using pyplot
         : image: 2d resolution image
         : return plt: pylab object
         """
 …
         return plt
     def reset_image(self):
         """
 …
         """
         self.image = []
     def get_variance(self, size=[], distance=0, phi=0, comp='radial'):
         """
 …
         : distance: [z, x] where z along the incident beam, x // qx_value
         : comp: direction of the sigma; can be 'phi', 'y', 'x', and 'radial'
         : return variance: sigma^2
         """
         # check the length of size (list)
         len_size = len(size)
         # define sigma component direction
         if comp == 'radial':
 …
         """
         Get the variance when the wavelength spread is given
         : radius: the radial distance from the beam center to the pix of q
         : distance: sample to detector distance
         : spread: wavelength spread (ratio)
         : comp: direction of the sigma; can be 'phi', 'y', 'x', and 'radial'
         : return variance: sigma^2 for 2d, sigma^2 for 1d [tuple]
         """
 …
             else:
                 sigma *= 1
             return sigma, sigma1d
 …
         """
         Get the variance from gravity when the wavelength spread is given
         : s_distance: source to sample distance
         : d_distance: sample to detector distance
 …
         : spread: wavelength spread (ratio)
         : comp: direction of the sigma; can be 'phi', 'y', 'x', and 'radial'
         : return variance: sigma^2
         """
 …
             sigma *= math.pow(spread, 2)
             sigma *= 8
-            # only for the polar coordinate
-            #if comp == 'radial':
-            #    sigma *= (math.sin(phi) * math.sin(phi))
-            #elif comp == 'phi':
-            #    sigma *= (math.cos(phi) * math.cos(phi))
             return sigma
     def _cal_A_value(self, lamda, s_distance, d_distance):
         """
         Calculate A value for gravity
         : s_distance: source to sample distance
         : d_distance: sample to detector distance
 …
             a_value *= (4 * lamda * lamda)
         return a_value
     def get_intensity(self):
         """
 …
         """
         return self.wave.wavelength
+    #TODO: why was this method duplicated?
+    #def get_spectrum(self):
+    #    """
+    #    Get spectrum
+    #    """
+    #    return self.wave.spectrum
     def get_default_spectrum(self):
         """
 …
         """
         return self.wave.get_default_spectrum()
     def get_spectrum(self):
         """
 …
         """
         return self.wave.get_spectrum()
     def get_wavelength_spread(self):
         """
 …
         """
         return self.wave.wavelength_spread
     def get_neutron_mass(self):
         """
 …
         """
         return self.wave.mass
     def get_source_aperture_size(self):
         """
 …
         """
         return self.aperture.source_size
     def get_sample_aperture_size(self):
         """
 …
         """
         return self.aperture.sample_size
     def get_detector_pix_size(self):
         """
 …
         """
         return self.detector.pix_size
     def get_detector_size(self):
         """
 …
         """
         return self.detector.size
     def get_source2sample_distance(self):
         """
 …
         """
         return self.aperture.sample_distance
     def get_sample2sample_distance(self):
         """
 …
         """
         return self.sample.distance
     def get_sample2detector_distance(self):
         """
 …
         """
         return self.detector.distance
     def set_intensity(self, intensity):
         """
 …
         """
         self.wave.set_intensity(intensity)
     def set_wave(self, wavelength):
         """
 …
         else:
             raise
     def set_wave_spread(self, wavelength_spread):
         """
 …
         elif wavelength_spread.__class__.__name__ == 'float':
             self.wave.set_wave_spread_list([wavelength_spread])
-            #self.set_wavelength_spread(wavelength_spread)
         else:
             raise
     def set_wavelength(self, wavelength):
         """
 …
         self.wavelength = wavelength
         self.wave.set_wavelength(wavelength)
     def set_spectrum(self, spectrum):
         """
 …
         self.spectrum = spectrum
         self.wave.set_spectrum(spectrum)
     def set_wavelength_spread(self, wavelength_spread):
         """
 …
         self.wavelength_spread = wavelength_spread
         self.wave.set_wavelength_spread(wavelength_spread)
     def set_wave_list(self, wavelength_list, wavelengthspread_list):
         """
 …
         self.wave.set_wave_list(wavelength_list)
         self.wave.set_wave_spread_list(wavelengthspread_list)
     def get_wave_list(self):
         """
 …
         """
         return self.wave.get_wave_list()
     def get_intensity_list(self):
         """
 …
         """
         return self.wave.get_intensity_list()
     def set_source_aperture_size(self, size):
         """
         Set source aperture size
         : param size: [dia_value] or [x_value, y_value]
         """
 …
             raise RuntimeError, "The length of the size must be one or two."
         self.aperture.set_source_size(size)
     def set_neutron_mass(self, mass):
         """
 …
         self.wave.set_mass(mass)
         self.mass = mass
     def set_sample_aperture_size(self, size):
         """
         Set sample aperture size
         : param size: [dia_value] or [xheight_value, yheight_value]
         """
 …
             raise RuntimeError, "The length of the size must be one or two."
         self.aperture.set_sample_size(size)
     def set_detector_pix_size(self, size):
         """
 …
         """
         self.detector.set_pix_size(size)
     def set_detector_size(self, size):
         """
 …
         """
         self.detector.set_size(size)
     def set_source2sample_distance(self, distance):
         """
         Set detector source2sample_distance
         : param distance: [distance, x_offset]
         """
 …
         """
         Set detector sample_slit2sample_distance
         : param distance: [distance, x_offset]
         """
 …
             raise RuntimeError, "The length of the size must be one or two."
         self.sample.set_distance(distance)
     def set_sample2detector_distance(self, distance):
         """
         Set detector sample2detector_distance
         : param distance: [distance, x_offset]
         """
 …
             raise RuntimeError, "The length of the size must be one or two."
         self.detector.set_distance(distance)
     def get_all_instrument_params(self):
         """
         Get all instrumental parameters
         """
-        #self.intensity = self.get_intensity()
-        #self.wavelength = self.get_wavelength()
-        #self.wavelength_spread = self.get_wavelength_spread()
         self.mass = self.get_neutron_mass()
         self.spectrum = self.get_spectrum()
 …
         self.sample2sample_distance = self.get_sample2sample_distance()
         self.sample2detector_distance = self.get_sample2detector_distance()
     def get_detector_qrange(self):
         """
         get max detector q ranges
         : return: qx_min, qx_max, qy_min, qy_max tuple
         """
 …
         qy_min = self.qyrange[0]
         qy_max = self.qyrange[1]
         return qx_min, qx_max, qy_min, qy_max
     def _rotate_z(self, x_value, y_value, theta=0.0):
         """
 …
         : y_value: numpy array of y values
         : theta: angle to rotate by in rad
         :return: x_prime, y-prime
         """
+        """
         # rotate by theta
         x_prime = x_value * math.cos(theta) + y_value * math.sin(theta)
         y_prime = -x_value * math.sin(theta) + y_value * math.cos(theta)
         return x_prime, y_prime
     def _gaussian2d(self, x_val, y_val, x0_val, y0_val,
                     sigma_x, sigma_y, sigma_r):
 …
         : sigma_x: variance in x-direction
         : sigma_y: variance in y-direction
         : return: gaussian (value)
         """
 …
         y_value = y_val - y0_val
         phi_i = numpy.arctan2(y_val, x_val)
         # phi correction due to the gravity shift (in phi)
         phi_0 = math.atan2(y0_val, x0_val)
 …
         sin_phi = numpy.sin(self.gravity_phi)
         cos_phi = numpy.cos(self.gravity_phi)
         x_p = x_value * cos_phi + y_value * sin_phi
         y_p = -x_value * sin_phi + y_value * cos_phi
         new_sig_x = sqrt(sigma_r * sigma_r / (sigma_x * sigma_x) + 1)
         new_sig_y = sqrt(sigma_r * sigma_r / (sigma_y * sigma_y) + 1)
 …
         : sigma_y: variance in phi-direction
         : sigma_r: wavelength variance in r-direction
         : return: gaussian (value)
         """
 …
         gaussian  = self._gaussian1d(x_val, x0_val, sigma_x)
         gaussian *= self._gaussian1d(y_val, y0_val, sigma_y)
         # normalizing factor correction
         if sigma_x != 0 and sigma_y != 0:
             gaussian *= sqrt(2 * pi)
         return gaussian
     def _gaussian1d(self, value, mean, sigma):
         """
 …
         : mean: mean value
         : sigma: variance
         : return: gaussian (value)
         """
 …
             # normalize
             gaussian /= sqrt(2 * pi)
         return gaussian
     def _atan_phi(self, qy_value, qx_value):
         """
 …
         : qx_value: x component of q
         : qy_value: y component of q
         : return phi: the azimuthal angle of q on x-y plane
         """
 …
         Get the pixel positions of the detector in the qx_value-qy_value space
         """
         # update all param values
         self.get_all_instrument_params()
         # wavelength
         wavelength = self.wave.wavelength
         # Gavity correction
         delta_y = self._get_beamcenter_drop()  # in cm
         # detector_pix size
         detector_pix_size = self.detector_pix_size
 …
         except:
             pass
         # detector size in [no of pix_x,no of pix_y]
         detector_pix_nums_x = self.detector_size[0]
         # get pix_y if it exists, otherwse take it from [0]
         try:
 …
         except:
             detector_pix_nums_y = self.detector_size[0]
         # detector offset in pix number
         offset_x = detector_offset / pix_x_size
         offset_y = delta_y / pix_y_size
         # beam center position in pix number (start from 0)
         center_x, center_y = self._get_beamcenter_position(detector_pix_nums_x,
 …
         detector_ind_x = detector_ind_x - center_x
         detector_ind_y = detector_ind_y - center_y
         # unit correction in cm
         detector_ind_x = detector_ind_x * pix_x_size
         detector_ind_y = detector_ind_y * pix_y_size
         qx_value = numpy.zeros(len(detector_ind_x))
         qy_value = numpy.zeros(len(detector_ind_y))
 …
             qy_value[i] = self._get_qx(indy, sample2detector_distance, wavelength)
             i += 1
         # qx_value and qy_value values in array
         qx_value = qx_value.repeat(detector_pix_nums_y)
 …
         self.qy_min = numpy.min(qy_value)
         self.qy_max = numpy.max(qy_value)
         # Appr. min and max values of the detector display limits
         # i.e., edges of the last pixels.
 …
         self.qx_max += self._get_qx(0.5 * pix_x_size,
                                     sample2detector_distance, wavelength)
         # min and max values of detecter
         self.detector_qx_min = self.qx_min
 …
         self.detector_qy_min = self.qy_min
         self.detector_qy_max = self.qy_max
         # try to set it as a Data2D otherwise pass (not required for now)
         try:
 …
         except:
             pass
         return output
     def _get_qx(self, dx_size, det_dist, wavelength):
         """
         :param dx_size: x-distance from beam center [cm]
         :param det_dist: sample to detector distance [cm]
         :return: q-value at the given position
         """
 …
         qx_value = (2.0 * pi / wavelength) * numpy.sin(theta)
         return qx_value
     def _get_polar_value(self, qx_value, qy_value):
         """
         Find qr_value and phi from qx_value and qy_value values
         : return qr_value, phi
         """
 …
         # find angle phi
         phi = self._atan_phi(qy_value, qx_value)
         return qr_value, phi
     def _get_beamcenter_position(self, num_x, num_y, offset_x, offset_y):
         """
 …
         :param num_y: number of pixel in y-direction
         :param offset: detector offset in x-direction in pix number
         :return: pix number; pos_x, pos_y in pix index
         """
 …
         """
         Get the beam center drop (delta y) in y diection due to gravity
         :return delta y: the beam center drop in cm
         """

src/sas/calculator/slit_length_calculator.py

-                      r79492222
+                      r6bd3a8d1
     """
     def __init__(self):
         # x data
         self.x = None
 …
         #default slit length
         self.slit_length = 0.0
         # The unit is unknown from SAXSess profile:
         # It seems 1/nm but it could be not fixed,
         # so users should be notified to determine the unit by themselves.
         self.slit_length_unit = "unknown"
     def set_data(self, x=None, y=None):
         """
          Receive two vector x, y and prepare the slit calculator for
          computation.
         :param x: array
         :param y: array
 …
         self.x = x
         self.y = y
     def calculate_slit_length(self):
         """
         Calculate slit length.
         :return: the slit length calculated value.
         """
 …
         # find max y
         max_y = y.max()
         # initial values
         y_sum = 0.0
         y_max = 0.0
         ind = 0.0
         # sum 10 or more y values until getting max_y,
         while (True):
 …
                 y_max = y[ind]
             ind += 1
         # find the average value/2 of the top values
         y_half = y_sum/(2.0*ind)
         # defaults
         y_half_d = 0.0
 …
             if y[ind] < y_half:
                 break
         # y value and ind just before passed the spot of the half height
         y_half_u = y[ind-1]
         # get corresponding x values
         x_half_d = x[ind]
         x_half_u = x[ind-1]
         # calculate x at y = y_half using linear interpolation
         if y_half_u == y_half_d:
 …
                        + x_half_d * (y_half_u - y_half)) \
                         / (y_half_u - y_half_d)
         # Our slit length is half width, so just give half beam value
         slit_length = x_half
         # set slit_length
         self.slit_length = slit_length
         return self.slit_length
     def get_slit_length_unit(self):
         """

Note: See TracChangeset for help on using the changeset viewer.

Download in other formats: