-                      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
         """

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

SasView

Changeset 6bd3a8d1 in sasview for src/sas/calculator/resolution_calculator.py

Legend:

src/sas/calculator/resolution_calculator.py

Download in other formats: