数据分析模块

quatm.analysis package

Submodules

quatm.analysis.bright_spots module

Detect bright spots such as ions in an image. We use skimage.features.blob_dog for bright spot detection.

Input:

• Imagestream

Output:

• Imagestream:
  • np.array: Mask containing ones on the locations where the bright spots are
  • dict: N_bright the number of bright spots detected
• Datastream:
  • bloblist: the locations of the bright spots
  • dict: N_bright the number of bright spots detected

Properties:

• imagestreams ([str]): Input streams
• max_sigma (float): Parameter from blob_dog
• threshold (float): Parameter from blob_dog

Hint: Use the output stream as a mask in the image monitor.

class quatm.analysis.bright_spots.BrightSpots(name)

Bases: object

run()

quatm.analysis.bright_spots.main_run(name)

quatm.analysis.crashit module

Simulate a crashed analysis routine.

quatm.analysis.gaussfit module

Perform a 1D Gaussian fit on a dataset.

Fit function: [ f(x) = \frac{A_0}{\sqrt{2\pi}\sigma} e^{\frac{-(x-\mu)^2}{2\sigma^2}} + C ]

Output: The output is a datastream containing a dictionary with the fit results and a 2D array containing the fitted curve.

Fit parameter nomenclature:

• A0: ( A_0 )
• sigma: ( \sigma )
• pos: ( \mu )
• offset: ( C )
• height: ( \frac{A_0}{\sqrt{2\pi}\sigma} )

In older versions some of the parameters were named differently:

• area: ( A_0 )
• height: ( A_0 )

Format of the input datastream: The fit can handle two types of data:

• 1D numpy.array (data.ndim == 1): the y-values are taken from the data, and the x values are a linear spaced index from 0 to ny.
• 2D numpy.array:
  • x = data[0]
  • y = data[1]

Properties controlling the program:

• datastreams: list of input datastreams

class quatm.analysis.gaussfit.Gaussfit(name)

Bases: object

run()

quatm.analysis.gaussfit.main_run(name)

quatm.analysis.imagedivider module

Handle absorption imaging data. According to Beer’s Law, light travelling through an atomic cloud is attenuated by:

[ I = I_0 e^{-n(x,y)\sigma} ]

where ( I_0 ) is the intensity before the cloud (Imaging beam without atoms) and ( I ) is the attenuated intensity (Image with atoms), ( \sigma ) is the absorption cross section, and ( n(x,y) ) is the column density of the atoms. Transforming this equation allows us to determine the column density of the atoms from the import two images.

[ n(x,y) = \frac{ln(I_0/I)}{\sigma} ]

where ( \sigma ) is given by:

[ N_{atoms} = \frac{ln(I_0/I)}{\frac{\sigma_0}{1+(2\Delta/\Gamma)^2}} ]

where effscale rescales the value from atoms per ( m^2 ) to atoms per pixel.

[ \sigma_0 = \frac{\hbar\omega\Gamma}{2 I_{sat}/C_2} ]

where ( \omega ) is the angular frequency of the laser, ( \Gamma ) is the linewidth of the transition in angular frequencies, ( I_{sat} ) is the saturation intensity in SI units, and ( C_2 ) is the Clebsh-Gordon coefficient for the dipole transition.

Properties:

• imagestreams: input datastreams
• imageWithAtoms: index of the image containing the image data with atoms (0 being the first image in each run)
• imageWithoutAtoms: the image containing the image without atoms
• absorptionCrossection: defaults to ( \sigma_0 )
• detuning_rad: detuning of the imaging laser from resonance
• linewidth_rad: linewidth of the transition

class quatm.analysis.imagedivider.ImageSlice(name)

Bases: object

• C_2 = 0.6666666666666666
• gamma = 36897377.3978814
• h_bar = 1.0545716346179718e-34
• isat = 25.4
• omega = 2807325165778985.0

run()

• sig0 = 1.4335384024006802e-13

quatm.analysis.imagedivider.main_run(name)

quatm.analysis.imageselector module

Select one single image per shot from the stream using the imgindex.

Input:

• One image stream

Output:

• Imagestream: the selected image

Properties:

• imagestreams: ([str]) input image streams
• SelectedImage: (int) the number of the image to be selected counting from 0.

class quatm.analysis.imageselector.ImageSlice(name)

Bases: object

run()

quatm.analysis.imageselector.main_run(name)

quatm.analysis.imageslice module

Create linear traces and small subregions from image stream.

![Imageslice]

Input:

• Imagestream

Output:

• colsum_ (datastream): summation in the direction of columns (use only row that lie within the region of interest. (gray area))
• rowsum_ (datastream): summation along rows
• colsumcut_, rowsumcut_: use only data within the region of interest
• colint, rowint, colintcut, rowintcut: Perform numeric integration (which means the sum is multiplied by the metric pixel size)
• (imagestream): send the image within the ROI

Properties:

• cutimg: (bool) send the image inside the ROI
• colsum: send the column sum
• rowsum: send the sum over the rows
• colsumcut, rowsumcut: (bool) send the corresponding data restricted to the region of interest
• colint, rowint, colintcut, rowintcut: similar to the sum version but taking into account the scale. Therefore these versions can be treated as integrals

class quatm.analysis.imageslice.ImageSlice(name)

Bases: object

run()

quatm.analysis.imageslice.main_run(name)