def diff_tth_X(self, dx=0.1): """ Jerome peux-tu décrire de quoi il retourne ??? @param dx: ??? @type: float ??? @return: ??? @rtype: ??? """ f = self.ai.getFit2D() fp = f.copy() fm = f.copy() fm["centerX"] -= dx / 2.0 fp["centerX"] += dx / 2.0 ap = AzimuthalIntegrator() am = AzimuthalIntegrator() ap.setFit2D(**fp) am.setFit2D(**fm) dtthX = (ap.twoThetaArray(self.shape) - am.twoThetaArray(self.shape))\ / dx tth, I = self.ai.xrpd(self.img, max(self.shape)) dI = SGModule.getSavitzkyGolay(I, npoints=5, degree=2, order=1)\ / (tth[1] - tth[0]) dImg = self.reconstruct(tth, dI) return (dtthX * dImg).sum()
def setUp(self): # defining geometry image_shape = [2048, 2048] # pixel detector_distance = 200 # mm wavelength = 0.31 # angstrom center_x = 1024 # pixel center_y = 1024 # pixel self.tilt = 0 # degree self.rotation = 0 # degree pixel_size = 79 # um dummy_tth = np.linspace(0, 35, 2000) dummy_int = np.ones(dummy_tth.shape) self.geometry = AzimuthalIntegrator() self.geometry.setFit2D(directDist=detector_distance, centerX=center_x, centerY=center_y, tilt=self.tilt, tiltPlanRotation=self.rotation, pixelX=pixel_size, pixelY=pixel_size) self.geometry.wavelength = wavelength / 1e10 self.dummy_img = self.geometry.calcfrom1d(dummy_tth, dummy_int, shape=image_shape, correctSolidAngle=True) self.tth_array = self.geometry.twoThetaArray(image_shape) self.azi_array = self.geometry.chiArray(image_shape)
def setup_integrator(self): """Sets up integrator object""" # if self.poni_file is not None: if self.poni_dict is not None: # poni_dict = get_poni_dict(self.poni_file) integrator = create_ai_from_dict(self.poni_dict, self.gi) # if not self.gi: # integrator = pyFAI.load(self.poni_file) # integrator._rot3 -= np.deg2rad(90) # else: # pFAI = pyFAI.load(self.poni_file) # calib_pars = dict( # dist=pFAI.dist, poni1=pFAI.poni1, poni2=pFAI.poni2, # rot1=pFAI.rot1, rot2=pFAI.rot2, rot3=pFAI.rot3, # wavelength=pFAI.wavelength, detector=pFAI.detector) # integrator = pygix.Transform(**calib_pars) # integrator.sample_orientation = 3 # 1 is horizontal, 2 is vertical else: integrator = AzimuthalIntegrator(dist=self.poni.dist, poni1=self.poni.poni1, poni2=self.poni.poni2, rot1=self.poni.rot1, rot2=self.poni.rot2, rot3=self.poni.rot3, wavelength=self.poni.wavelength, detector=self.poni.detector, **self.ai_args) return integrator
def scan_Fit2D(self, width=1.0, points=10, axis="tilt", dx=0.1): """ ??? @param width: ??? @type width: float ??? @param points: ??? @type points: int ??? @param axis: ??? @type axis: str ??? @param dx: ??? @type dx: float ??? @return: ??? @rtype: ??? """ logger.info("Scanning along axis %s" % axis) f = self.ai.getFit2D() out = [] meas_pts = numpy.linspace(f[axis] - width / 2.0, f[axis] + width / 2.0, points) for x in meas_pts: ax = AzimuthalIntegrator() fx = f.copy() fx[axis] = x ax.setFit2D(**fx) ref = Refinment2D(self.img, ax) res = ref.diff_Fit2D(axis=axis, dx=dx) print("x= %.3f mean= %e" % (x, res)) out.append(res) return meas_pts, out
def scan_tilt(self, width=1.0, points=10): """ ??? @param width: ??? @type width: float ??? @param points: ??? @type points: int ??? @return: ??? @rtype: ??? """ f = self.ai.getFit2D() out = [] for x in numpy.linspace(f["tilt"] - width / 2.0, f["tilt"] + width / 2.0, points): ax = AzimuthalIntegrator() fx = f.copy() fx["tilt"] = x ax.setFit2D(**fx) # print ax ref = Refinment2D(self.img, ax) res = ref.diff_tth_tilt() print("x= %.3f mean= %e" % (x, res)) out.append(res) return numpy.linspace(f["tilt"] - width / 2.0, f["tilt"] + width / 2.0, points), out
def setUp(self): """Download files""" self.fit2dFile = UtilsTest.getimage(self.__class__.fit2dFile) self.halfFrelon = UtilsTest.getimage(self.__class__.halfFrelon) self.splineFile = UtilsTest.getimage(self.__class__.splineFile) poniFile = UtilsTest.getimage(self.__class__.poniFile) with open(poniFile) as f: data = [] for line in f: if line.startswith("SplineFile:"): data.append("SplineFile: " + self.splineFile) else: data.append(line.strip()) self.poniFile = os.path.join(self.tmp_dir, os.path.basename(poniFile)) if not os.path.isdir(self.tmp_dir): os.makedirs(self.tmp_dir) with open(self.poniFile, "w") as f: f.write(os.linesep.join(data)) self.fit2d = numpy.loadtxt(self.fit2dFile) self.ai = AzimuthalIntegrator() self.ai.load(self.poniFile) self.data = fabio.open(self.halfFrelon).data for tmpfile in self.tmpfiles.values(): if os.path.isfile(tmpfile): os.unlink(tmpfile)
def _update_integrator(self): constant = 1e-3 * constants.c * constants.h / constants.e self._wavelength = constant / self._ai_params["energy"] self._distance = self._ai_params["distance"] self._poni1 = \ self._ai_params["centery"] * self._ai_params["pixel_size"] self._poni2 = \ self._ai_params["centerx"] * self._ai_params["pixel_size"] if self._ai_integrator is None: self._ai_integrator = AzimuthalIntegrator( dist=self._ai_params["distance"], pixel1=self._ai_params["pixel_size"], pixel2=self._ai_params["pixel_size"], poni1=self._poni1, poni2=self._poni2, rot1=0, rot2=0, rot3=0, wavelength=self._wavelength) else: if self._ai_integrator.dist != self._distance \ or self._ai_integrator.wavelength != self._wavelength \ or self._ai_integrator.poni1 != self._poni1 \ or self._ai_integrator.poni2 != self._poni2: self._ai_integrator.set_param( (self._distance, self._poni1, self._poni2, 0, 0, 0, self._wavelength)) return self._ai_integrator
def load_from_h5(self, file): """Loads data from hdf5 file and sets attributes. args: file: h5py file or group object returns: None """ with self.file_lock: with self.arch_lock: if str(self.idx) not in file: print("No data can be found") grp = file[str(self.idx)] lst_attr = [ "map_raw", "mask", "map_norm", "map_q", "xyz", "tcr", "qchi", "scan_info", "ai_args" ] pawstools.h5_to_attributes(self, grp, lst_attr) pawstools.h5_to_attributes(self.int_1d, grp['int_1d']) pawstools.h5_to_attributes(self.int_2d, grp['int_2d']) self.poni = PONI.from_yamdict(pawstools.h5_to_dict( grp['poni'])) self.integrator = AzimuthalIntegrator( dist=self.poni.dist, poni1=self.poni.poni1, poni2=self.poni.poni2, rot1=self.poni.rot1, rot2=self.poni.rot2, rot3=self.poni.rot3, wavelength=self.poni.wavelength, detector=self.poni.detector, **self.ai_args)
def _update_integrator(self): if self._integrator is None: self._integrator = AzimuthalIntegrator(dist=self._sample_dist, pixel1=self._pixel1, pixel2=self._pixel2, poni1=self._poni1, poni2=self._poni2, rot1=0, rot2=0, rot3=0, wavelength=self._wavelength) else: if self._integrator.dist != self._sample_dist \ or self._integrator.wavelength != self._wavelength \ or self._integrator.poni1 != self._poni1 \ or self._integrator.poni2 != self._poni2: # dist, poni1, poni2, rot1, rot2, rot3, wavelength self._integrator.set_param( (self._sample_dist, self._poni1, self._poni2, 0, 0, 0, self._wavelength)) try: # 1/nm -> 1/A self._q_map = 0.1 * self._integrator._cached_array["q_center"] except KeyError: pass return self._integrator
def diff_Fit2D(self, axis="all", dx=0.1): """ ??? @param axis: ??? @type axis: ??? @param dx: ??? @type dx: ??? @return: ??? @rtype: ??? """ tth, I = self.ai.xrpd(self.img, max(self.shape)) dI = SGModule.getSavitzkyGolay(I, npoints=5, degree=2, order=1)\ / (tth[1] - tth[0]) dImg = self.reconstruct(tth, dI) f = self.ai.getFit2D() tth2d_ref = self.ai.twoThetaArray(self.shape) # useless variable ??? keys = ["centerX", "centerY", "tilt", "tiltPlanRotation"] if axis != "all": keys = [i for i in keys if i == axis] grad = {} for key in keys: fp = f.copy() fp[key] += dx ap = AzimuthalIntegrator() ap.setFit2D(**fp) dtth = (ap.twoThetaArray(self.shape) - self.ai.twoThetaArray(self.shape)) / dx grad[key] = (dtth * dImg).sum() if axis == "all": return grad else: return grad[axis]
def set_geometry(distance: float = 1, center_x: float = 0, center_y: float = 0, tilt: float = 0.0, tilt_plane_rotation: float = 0.0): ai = AzimuthalIntegrator() ai.setFit2D(distance, center_x, center_y, tilt, tilt_plane_rotation) return ai
def setup_calibration(self, calib): """set up calibration from calibration dict""" if self.image.rot90 in (1, 3): calib['rot3'] = np.pi / 2.0 self.calib = calib if HAS_PYFAI: self.integrator = AzimuthalIntegrator(**calib) self.show1d_btn.Enable()
def update_ai(self, center=None, nbins=1000): if center is None: center = self.center ai = AzimuthalIntegrator(detector=self.detector, dist=self.distance) ai.setFit2D(self.distance * 1000, center[0], center[1]) ai.wavelength = self.wavelength * 1e-10 return ai
def setUp(self): self.edfPilatus = UtilsTest.getimage(self.__class__.saxsPilatus) self.maskFile = UtilsTest.getimage(self.__class__.maskFile) self.poniFile = UtilsTest.getimage(self.__class__.poniFile) self.maskRef = UtilsTest.getimage(self.__class__.maskRef) self.maskDummy = UtilsTest.getimage(self.__class__.maskDummy) self.ai = AzimuthalIntegrator() self.ai.load(self.poniFile) if not os.path.isdir(self.tmp_dir): os.mkdir(self.tmp_dir)
def load_from_h5(self, file, load_2d=True): """Loads data from hdf5 file and sets attributes. args: file: h5py file or group object """ with self.file_lock: with self.arch_lock: if str(self.idx) not in file: print("No data can be found") else: grp = file[str(self.idx)] if 'type' in grp.attrs: if grp.attrs['type'] == 'EwaldArch': lst_attr = [ "map_raw", "mask", "map_norm", "scan_info", "ai_args", "gi", "static", "poni_dict" # "poni_file", "gi", "static", "poni_dict" ] utils.h5_to_attributes(self, grp, lst_attr) self.int_1d.from_hdf5(grp['int_1d']) if load_2d: self.int_2d.from_hdf5(grp['int_2d']) self.poni = PONI.from_yamdict( utils.h5_to_dict(grp['poni'])) # if self.poni_file is not None: if self.poni_dict is not None: self.integrator = create_ai_from_dict( self.poni_dict) # if not self.gi: # self.integrator = pyFAI.load(self.poni_file) # self.integrator._rot3 -= np.deg2rad(90) # else: # pFAI = pyFAI.load(self.poni_file) # calib_pars = dict( # dist=pFAI.dist, poni1=pFAI.poni1, poni2=pFAI.poni2, # rot1=pFAI.rot1, rot2=pFAI.rot2, rot3=pFAI.rot3, # wavelength=pFAI.wavelength, detector=pFAI.detector) # self.integrator = pygix.Transform(**calib_pars) # self.integrator.sample_orientation = 3 # 1 is horizontal, 2 is vertical # self.integrator.incident_angle = 1 # incident angle in deg # self.integrator.tilt_angle = 0 # tilt angle of sample in deg (misalignment in "chi") else: self.integrator = AzimuthalIntegrator( dist=self.poni.dist, poni1=self.poni.poni1, poni2=self.poni.poni2, rot1=self.poni.rot1, rot2=self.poni.rot2, rot3=self.poni.rot3, wavelength=self.poni.wavelength, detector=self.poni.detector, **self.ai_args)
def read_config(self): calfile = self.scandb.get_info('xrd_calibration') self.label = self.scandb.get_info('xrd_1dint_label') self.folder = self.scandb.get_info('map_folder') if self.folder.endswith('/'): self.folder = self.folder[:-1] calib = json.loads(self.scandb.get_detectorconfig(calfile).text) print("Read Integration configuration: ", calfile) if HAS_PYFAI: self.integrator = AzimuthalIntegrator(**calib)
def test_get_extent(self): dect = Detector(pixel1=1e-4, pixel2=1e-4) ai = AzimuthalIntegrator(detector=dect, dist=0.1) ai.setFit2D(directDist=1000, centerX=50.5, centerY=50.5) extent = _get_radial_extent(ai=ai, shape=(100, 100), unit="2th_rad") max_rad = 50 * np.sqrt(2) calc_extent = np.arctan(max_rad * 1e-4 / 1) np.testing.assert_almost_equal( extent[1], calc_extent, )
def azimuthal_integrate( z, origin, detector_distance, detector, wavelength, size_1d, unit, kwargs_for_integrator, kwargs_for_integrate1d, ): """Calculate the azimuthal integral of z around a determined origin. This method is used for signals where the origin is iterated, compared to azimuthal_integrate_fast which is used when the origin in the data is constant. Parameters ---------- z : np.array() Two-dimensional data array containing the signal. origin : np.array() A size 2 numpy array containing the position of the origin. detector_distance : float Detector distance in meters passed to pyFAI AzimuthalIntegrator. detector : pyFAI.detectors.Detector object A pyFAI detector used for the AzimuthalIntegrator. wavelength : float The electron wavelength in meters. Used by pyFAI AzimuthalIntegrator. size_1d : int The size of the returned 1D signal. (i.e. number of pixels in the 1D azimuthal integral.) unit : str The unit for for PyFAI integrate1d. *args : Arguments to be passed to AzimuthalIntegrator. **kwargs : Keyword arguments to be passed to AzimuthalIntegrator. Returns ------- tth : np.array() One-dimensional scattering vector axis of z. I : np.array() One-dimensional azimuthal integral of z. """ p1, p2 = origin[0] * detector.pixel1, origin[1] * detector.pixel2 ai = AzimuthalIntegrator(dist=detector_distance, poni1=p1, poni2=p2, detector=detector, wavelength=wavelength, **kwargs_for_integrator) tth, I = ai.integrate1d(z, size_1d, unit=unit, **kwargs_for_integrate1d) return tth, I
def run(self): ai = AzimuthalIntegrator(dist=self.__distance, poni1=self.__poni1, poni2=self.__poni2, rot1=self.__rotation1, rot2=self.__rotation2, rot3=self.__rotation3, detector=self.__detector, wavelength=self.__wavelength) # FIXME error model, method self.__result1d = ai.integrate1d( data=self.__image, npt=self.__nPointsRadial, unit=self.__radialUnit, mask=self.__mask, polarization_factor=self.__polarizationFactor) self.__result2d = ai.integrate2d( data=self.__image, npt_rad=self.__nPointsRadial, npt_azim=self.__nPointsAzimuthal, unit=self.__radialUnit, mask=self.__mask, polarization_factor=self.__polarizationFactor) try: self.__directDist = ai.getFit2D()["directDist"] except Exception: # The geometry could not fit this param _logger.debug("Backtrace", exc_info=True) self.__directDist = None if self.__calibrant: rings = self.__calibrant.get_2th() try: rings = utils.from2ThRad(rings, self.__radialUnit, self.__wavelength, self.__directDist) except ValueError: message = "Convertion to unit %s not supported. Ring marks ignored" _logger.warning(message, self.__radialUnit) rings = [] # Filter the rings which are not part of the result rings = filter( lambda x: self.__result1d.radial[0] <= x <= self.__result1d. radial[-1], rings) rings = list(rings) else: rings = [] self.__ringAngles = rings self.__ai = ai
def get_azimuthal_integrator(detector, detector_distance, shape, center=None, affine=None, mask=None, wavelength=None, **kwargs): """Basic method for creating a azimuthal integrator. This helps to deal with taking some of the pyXEM standards and apply them to pyFAI Parameters ---------- detector: pyFAI.detectors.Detector The detector to be integrated detector_distance: distance sample - detector plan (orthogonal distance, not along the beam), in meter. shape: (int, int) The shape of the signal we are operating on. For the center: (float, float) The center of the diffraction pattern affine: (3x3) The affine transformation to apply to the data mask: np.array A boolean array to be added to the integrator. wavelength: float The wavelength of the beam in meter. Needed to accounting for the Ewald sphere. kwargs: dict Any additional arguments to the Azimuthal Integrator class """ if center is None: center = np.divide(shape, 2) # Center is middle of the image if affine is not None: # create spline representation with (dx,dy) displacements dx, dy = _get_displacements(center=center, shape=shape, affine=affine) detector.max_shape = shape detector.shape = shape detector.set_dx(dx) detector.set_dy(dy) ai = AzimuthalIntegrator(detector=detector, dist=detector_distance, wavelength=wavelength, **kwargs) if mask is not None: ai.set_mask(mask) if wavelength is not None: ai.wavelength = wavelength ai.setFit2D(directDist=detector_distance * 1000, centerX=center[1], centerY=center[0]) return ai
def __init__(self, img, ai=None): """ @param img: raw image we are working on @type img: ndarray @param ai: azimuhal integrator we are working on @type ai: pyFAI.azimuthalIntegrator.AzimutalIntegrator """ self.img = img if ai is None: self.ai = AzimuthalIntegrator() else: self.ai = ai
def addDevice(self, device): if device: try: self.setSilence(True) devicechild = DeviceParameter(device) self.addChild(devicechild) ai = AzimuthalIntegrator(wavelength=self['Wavelength']) ai.detector = detectors.Pilatus2M() self.AIs[device] = ai self.multiAI.ais = list(self.AIs.values()) finally: self.setSilence(False)
def openPoniFile(self, file=None): """ Select and imports the calibration file """ if file is None: self.poniFile = QFileDialog.getOpenFileName( self, 'Select calibration file', directory=self.curDir, filter='Calibration file (*.poni)')[0] self.poniFileLineEdit.setText(self.poniFile) else: self.poniFile = file if os.path.exists(self.poniFile): self.setup_dict['poniFile'] = self.poniFile json.dump(self.setup_dict, open('./SetupData/reducer_setup.txt', 'w')) fh = open(self.poniFile, 'r') lines = fh.readlines() self.calib_data = {} for line in lines: if line[0] != '#': key, val = line.split(': ') self.calib_data[key] = float(val) self.dist = self.calib_data['Distance'] self.pixel1 = self.calib_data['PixelSize1'] self.pixel2 = self.calib_data['PixelSize2'] self.poni1 = self.calib_data['Poni1'] self.poni2 = self.calib_data['Poni2'] self.rot1 = self.calib_data['Rot1'] self.rot2 = self.calib_data['Rot2'] self.rot3 = self.calib_data['Rot3'] self.wavelength = self.calib_data['Wavelength'] self.ai = AzimuthalIntegrator(dist=self.dist, poni1=self.poni1, poni2=self.poni2, pixel1=self.pixel1, pixel2=self.pixel2, rot1=self.rot1, rot2=self.rot2, rot3=self.rot3, wavelength=self.wavelength) #pos=[self.poni2/self.pixel2,self.poni1/self.pixel1] #self.roi=cake(pos,movable=False) #self.roi.sigRegionChangeStarted.connect(self.endAngleChanged) #self.imageView.addItem(self.roi) else: QMessageBox.warning( self, 'File error', 'The calibration file ' + self.poniFile + ' doesnot exists.', QMessageBox.Ok)
def create_cake_geometry(self): self.cake_geometry = AzimuthalIntegrator() pyFAI_parameter = self.pattern_geometry.getPyFAI() pyFAI_parameter['wavelength'] = self.pattern_geometry.wavelength self.cake_geometry.setPyFAI(dist=pyFAI_parameter['dist'], poni1=pyFAI_parameter['poni1'], poni2=pyFAI_parameter['poni2'], rot1=pyFAI_parameter['rot1'], rot2=pyFAI_parameter['rot2'], rot3=pyFAI_parameter['rot3'], pixel1=pyFAI_parameter['pixel1'], pixel2=pyFAI_parameter['pixel2']) self.cake_geometry.wavelength = pyFAI_parameter['wavelength']
def test_AzimuthalIntegrator_pickle(): import dill import numpy as np from pyFAI.azimuthalIntegrator import AzimuthalIntegrator det = pyFAI.detectors.detector_factory('pilatus2m') ai = AzimuthalIntegrator(detector=det) ai.set_wavelength(.1) spectra = ai.integrate1d(np.ones(det.shape), 1000) # force lut generation dump = dumps(ai) newai = loads(dump) assert np.array_equal(newai.integrate1d(np.ones(det.shape), 1000), spectra) assert newai.detector.shape == (1679, 1475)
def setUp(self): unittest.TestCase.setUp(self) self.data = fabio.open(UtilsTest.getimage("1788/moke.tif")).data self.lst_data = [ self.data[:250, :300], self.data[250:, :300], self.data[:250, 300:], self.data[250:, 300:] ] self.det = Detector(1e-4, 1e-4) self.det.max_shape = (500, 600) self.sub_det = Detector(1e-4, 1e-4) self.sub_det.max_shape = (250, 300) self.ai = AzimuthalIntegrator(0.1, 0.03, 0.03, detector=self.det) self.range = (0, 23) self.ais = [ AzimuthalIntegrator(0.1, 0.030, 0.03, detector=self.sub_det), AzimuthalIntegrator(0.1, 0.005, 0.03, detector=self.sub_det), AzimuthalIntegrator(0.1, 0.030, 0.00, detector=self.sub_det), AzimuthalIntegrator(0.1, 0.005, 0.00, detector=self.sub_det), ] self.mg = MultiGeometry(self.ais, radial_range=self.range, unit="2th_deg") self.N = 390
def setUp(self): self.ai = AzimuthalIntegrator() shape = (10, 15) self.rnd1 = numpy.random.random(shape).astype(numpy.float32) self.rnd2 = numpy.random.random(shape).astype(numpy.float32) testdir = os.path.join(os.path.dirname(__file__), "tmp") if not os.path.isdir(testdir): os.makedirs(testdir) fd, self.edf1 = tempfile.mkstemp(".edf", "testAI1", testdir) os.close(fd) fd, self.edf2 = tempfile.mkstemp(".edf", "testAI2", testdir) os.close(fd) fabio.edfimage.edfimage(data=self.rnd1).write(self.edf1) fabio.edfimage.edfimage(data=self.rnd2).write(self.edf2)
def load(self, filename): """ Loads a calibration file and and sets all the calibration parameter. :param filename: filename for a *.poni calibration file """ self.pattern_geometry = AzimuthalIntegrator() self.pattern_geometry.load(filename) self.orig_pixel1 = self.pattern_geometry.pixel1 self.orig_pixel2 = self.pattern_geometry.pixel2 self.calibration_name = get_base_name(filename) self.filename = filename self.is_calibrated = True self.create_cake_geometry() self.set_supersampling()
def setUp(self): self.ai = AzimuthalIntegrator() shape = (10, 15) self.rnd1 = numpy.random.random(shape).astype(numpy.float32) self.rnd2 = numpy.random.random(shape).astype(numpy.float32) if not os.path.isdir(self.tmp_dir): os.mkdir(self.tmp_dir) fd, self.edf1 = tempfile.mkstemp(".edf", "testAI1", self.tmp_dir) os.close(fd) fd, self.edf2 = tempfile.mkstemp(".edf", "testAI2", self.tmp_dir) os.close(fd) fabio.edfimage.edfimage(data=self.rnd1).write(self.edf1) fabio.edfimage.edfimage(data=self.rnd2).write(self.edf2)
def __init__(self, img_model=None): super(CalibrationModel, self).__init__() """ :param img_model: :type img_model: ImgModel """ self.img_model = img_model self.points = [] self.points_index = [] self.pattern_geometry = AzimuthalIntegrator() self.pattern_geometry_img_shape = None self.cake_geometry = None self.cake_geometry_img_shape = None self.calibrant = Calibrant() self.pattern_geometry.wavelength = 0.3344e-10 self.start_values = {'dist': 200e-3, 'wavelength': 0.3344e-10, 'pixel_width': 79e-6, 'pixel_height': 79e-6, 'polarization_factor': 0.99} self.orig_pixel1 = 79e-6 self.orig_pixel2 = 79e-6 self.fit_wavelength = False self.fit_distance = True self.fit_poni1 = True self.fit_poni2 = True self.fit_rot1 = True self.fit_rot2 = True self.fit_rot3 = True self.is_calibrated = False self.use_mask = False self.filename = '' self.calibration_name = 'None' self.polarization_factor = 0.99 self.supersampling_factor = 1 self.correct_solid_angle = True self._calibrants_working_dir = calibrants_path self.distortion_spline_filename = None self.tth = np.linspace(0, 25) self.int = np.sin(self.tth) self.num_points = len(self.int) self.cake_img = np.zeros((2048, 2048)) self.cake_tth = None self.cake_azi = None self.peak_search_algorithm = None