def spectrumAllData(self, data_file_path): ''' Parameters ---------- data_file_path: string measurement data folder Returns ------- spe_tip: numpy array spectrum obtained by fft of tip data freq_tip: numpy array frequency obtained by fft of tip data spe_tilt: numpy array spectrum obtained by fft of tilt data freq_tilt: numpy array frequency obtained by fft of tilt data ''' list = glob.glob(os.path.join(data_file_path, '*.h5')) coef_tilt_list = [] coef_tip_list = [] for i in range(len(list)): name = 'img_%04d.h5' % i print(name) file_name = os.path.join(data_file_path, name) start_image = self._ic.from4D(file_name) coef, mat = zernike.zernikeFit(start_image, np.array([2, 3])) coef_tip_list.append(coef[0]) coef_tilt_list.append(coef[1]) tip = np.array(coef_tip_list) tilt = np.array(coef_tilt_list) spe_tip, freq_tip = self._fft(tip) spe_tilt, freq_tilt = self._fft(tilt) return spe_tip, freq_tip, spe_tilt, freq_tilt
def zernikeTipTiltCoefOnSingleImage(interf, masked_ima=None): """ On single image returns the coefficients of tip and tilt both in Zernike of Noll and in units of the interferometer Parameters ---------- interf: object interferometer object Other Parameters --------------- masked_ima: numpy masked array if it is not passed acquires the interferometer Returns ------- tip_tilt: numpy array Zernike Noll coefficients i4d_coef: numpy array Interferometers values """ if masked_ima is None: masked_ima = interf.acquire_phasemap(1) else: masked_ima = masked_ima coef, mat = zernike.zernikeFit(masked_ima, np.array([2, 3])) tip = -coef[0] / (633e-9) * np.sqrt(2) tilt = coef[1] / (633e-9) * np.sqrt(2) i4d_coef = fit(masked_ima) return np.array([tip, tilt]), i4d_coef
def piston_noise(self, data_file_path): ''' Remove tip and tilt from image and average the results .. dovrei vedere una variazione nel tempo Parameters ---------- data_file_path: string measurement data folder Returns ------- mean: numpy array vector containing images's mean time: numpy array vector of the time at which the image were taken ''' list = glob.glob(os.path.join(data_file_path, '*.h5')) image_number = len(list) time = np.arange(image_number) * (1 / 27.58) mean_list = [] for j in range(image_number): name = 'img_%04d.h5' % j file_name = os.path.join(data_file_path, name) image = self._ic.from4D(file_name) zernike_coeff_array, mat = zernike.zernikeFit( image, np.array([2, 3])) sur = zernike.zernikeSurface(image, zernike_coeff_array, mat) image_ttr = image - sur mean = image_ttr.mean() mean_list.append(mean) spe, freq = self._fft(mean) return np.array(mean_list), time, spe, freq
def _createCubeTTrFromCube(self, fitEx=None): # ci mette un eternit a fare l estenzione dell immagine #cube = self._readCube() cube_ttr = None if fitEx is None: for i in range(self._cube.shape[2]): image = self._cube[:, :, i] coef, mat = zernike.zernikeFit(image, np.array([2, 3])) surf = zernike.zernikeSurface(image, coef, mat) image_ttr = image - surf if cube_ttr is None: cube_ttr = image_ttr else: cube_ttr = np.ma.dstack((cube_ttr, image_ttr)) else: for i in range(self._cube.shape[2]): coef, interf_coef = tip_tilt_interf_fit.fit(self._cube[:, :, i]) image_ttr = self._ttd.ttRemoverFromCoeff(coef, self._cube[:, :, i]) if cube_ttr is None: cube_ttr = image_ttr else: cube_ttr = np.ma.dstack((cube_ttr, image_ttr)) self._saveCube(cube_ttr, 'Total_Cube_ttr.fits') return cube_ttr
def tiptilt_series(self, data_file_path): ''' Remove tip and tilt from image and average the results .. dovrei vedere una variazione nel tempo Parameters ---------- data_file_path: string measurement data folder Returns ------- mean: numpy array vector containing images's mean time: numpy array vector of the time at which the image were taken ''' list = glob.glob(os.path.join(data_file_path, '*.h5')) image_number = len(list) time = np.arange(image_number) * (1 / 27.58) tt_list = [] for j in range(image_number): name = 'img_%04d.h5' % j file_name = os.path.join(data_file_path, name) image = self._ic.from4D(file_name) coeff, mat = zernike.zernikeFit(image, np.array([1, 2, 3])) tt_list.append(coeff) tt = np.array(tt_list) return tt
def testZernikeOnPar(self, image): ''' Parameters ---------- image: numpy masked array image to test Returns ------- coef1: coef2: ''' from m4.ground import zernike x, y = self.fiduciali(image) centro, axs, raggio = self._fitEllipse(x, y) pxs = raggio / OttParameters.RADIUS_FIDUCIAL_POINT par_radius = pxs * OttParameters.parab_radius # import pdb # pdb.set_trace() circle = self._drawCircle(centro, par_radius, image) ima = np.ma.masked_array(image, mask=np.invert(circle.astype(bool))) coef1, mat = zernike.zernikeFit(ima, np.arange(10) + 1) xx, yy = self.coord(image, centro, raggio) mm = (circle == 1) coef2 = zernike._surf_fit(xx[mm], yy[mm], image.data[mm], np.arange(10) + 1) return coef1, coef2
def _zernikeCoeffCalculator(self, img): """ Returns: final_coef = zernike coeff on the image (zernike modes 2,3,4,7,8) final_coef_selected = zernike selected using intMatModesVector (zernike2control) """ if fold_name.simulated == 1: mask_index = OtherParameters.MASK_INDEX_SIMULATORE else: mask_index = OtherParameters.MASK_INDEX_TOWER r = ROI() roi = r.roiGenerator(img) mask = roi[mask_index] mm = np.ma.mask_or(img.mask, mask) new_image = np.ma.masked_array(img, mask=mm) coef, mat = zernike.zernikeFit(new_image, np.arange(10) + 1) z = np.array([1, 2, 3, 6, 7]) all_final_coef = coef[z] if self._intMatModesVector is None: final_coef_selected = all_final_coef else: final_coef_selected = np.zeros(self._intMatModesVector.size) for i in range(self._intMatModesVector.size): final_coef_selected[i] = all_final_coef[ self._intMatModesVector[i]] return all_final_coef, final_coef_selected
def longTerm_rmsConvection(self): where = fold_name.OPD_SERIES_ROOT_FOLDER #where = '/mnt/m4storage/Data/M4Data/OPTData/OPD_series/' #where = '/home/labot/data/M4/Data/M4Data/OPTData/OPD_series' path = os.path.join(where, self.tt) D1 = sorted(glob.glob(os.path.join(path, '*.fits'))) #D = D1[0:-np.int(len(D1)/8)] D = D1[0:-2] cube = None for name in D: print(name) image = read_data.readFits_maskedImage(name) if cube is None: cube = image else: cube = np.ma.dstack((cube, image)) mean = np.ma.mean(cube, axis=2) rms_list = [] for i in range(cube.shape[2]): #print(i) ima = cube[:, :, i] - mean coef, mat = zernike.zernikeFit(ima, np.arange(8) + 1) surf = zernike.zernikeSurface(ima, coef, mat) new_ima = ima - surf rms = new_ima.std() rms_list.append(rms) rms = np.array(rms_list) x = np.arange(rms.size) x_list = [] for i in range(rms.size): aa = D[i].split('_')[-1] tt = aa.split('.')[0] x_list.append(tt) x_time = np.array(x_list) ntick = 11 plt.figure(figsize=(10, 6)) plt.plot(x, rms, '-') plt.xticks(x, x_time[::len(x_time) / ntick], rotation=45) plt.locator_params(nbins=ntick, axis='x', tight=True) plt.ylabel('rms[m]') plt.title('%s' % self.tt) results_path = os.path.join(fold_name.OUT_FOLDER, 'LongTermStability') dove = os.path.join(results_path, self.tt) if os.path.exists(dove): dove = dove else: os.makedirs(dove) name = os.path.join(dove, 'rmsMeanDiff.fits') pyfits.writeto(name, rms, overwrite=True) name = os.path.join(dove, '%s-rms.png' % self.tt) if os.path.isfile(name): os.remove(name) plt.savefig(name) return rms
def testZernike(self): img = np.random.rand(500, 500) mask = np.ones((500, 500), dtype=bool) rr, cc = circle(250, 250, 100) mask[rr, cc] = 0 masked_ima = np.ma.masked_array(img, mask=mask) coef, mat = zernike.zernikeFit(masked_ima, np.arange(10) + 1) zernike.zernikeSurface(masked_ima, coef, mat)
def tipTiltVSTime(self, data_file_path, start, stop): ''' Attenzione: questa funzione vuole il file path ''' last_name = data_file_path.split('/')[-1] if last_name == 'hdf5': list_tot = glob.glob(os.path.join(data_file_path, '*.h5')) tt = data_file_path.split('/')[-2] ext = 1 else: list_tot = glob.glob(os.path.join(data_file_path, '*.fits')) tt = data_file_path.split('/')[-1] ext = 0 list_tot.sort() list = list_tot[start:stop] if last_name == 'hdf5': time = np.arange(0, len(list)) * 1 / 27.58 else: time = 'calcolare dal tt' tip_tilt = [] for name in list: image = read_data.read_phasemap(name, ext) coef, mat = zernike.zernikeFit(image, np.array([1, 2, 3])) tip_tilt.append(coef) tip = np.array(tip_tilt)[:, 1] tilt = np.array(tip_tilt)[:, 2] #PLOT plt.figure(figsize=(10, 6)) plt.plot(time, tip * 1e9, label='TIP') plt.plot(time, tilt * 1e9, label='TILT') plt.legend() plt.title(tt) plt.ylabel('zernike coef [nm]') plt.xlabel('time [s]') #SAVE results_path = os.path.join(fold_name.OUT_FOLDER, 'Noise') x = data_file_path.split("/") if last_name == 'hdf5': dove = os.path.join(results_path, x[len(x) - 2]) else: dove = os.path.join(results_path, x[len(x) - 1]) if os.path.exists(dove): dove = dove else: os.makedirs(dove) name = os.path.join(dove, 'tipTilt_time.png') if os.path.isfile(name): os.remove(name) plt.savefig(name) return np.array(tip_tilt), time
def diffOpticalMonitoring(self, n_images, delayshort, delaylong): ''' # Fa due misure poco distanti tra loro e poi aspetta tanto Parameters ---------- n_images: int number of images to acquire delayshort: float time gap between images couple delaylong: float time gap between images couple Returns ------ tt: string tracking number of measurements ''' store_in_folder = fold_name.OPD_SERIES_ROOT_FOLDER dove, tt = tracking_number_folder.createFolderToStoreMeasurements( store_in_folder) zer_list = [] temp_list = [] t0 = time.time() for i in range(n_images): for i in range(2): ti = time.time() dt = ti - t0 masked_ima = self._interf.acquire_phasemap(1) temp_vect = self._ott.temperature.getTemperature() name = Timestamp.now() + '.fits' fits_file_name = os.path.join(dove, name) pyfits.writeto(fits_file_name, masked_ima.data) pyfits.append(fits_file_name, masked_ima.mask.astype(int)) coef, mat = zernike.zernikeFit(masked_ima, np.arange(10) + 1) vect = np.append(dt, coef) zer_list.append(vect) temp_list.append(temp_vect) fits_file_name = os.path.join(dove, 'zernike.fits') pyfits.writeto(fits_file_name, np.array(zer_list), overwrite=True) fits_file_name = os.path.join(dove, 'temperature.fits') pyfits.writeto(fits_file_name, np.array(temp_list), overwrite=True) print('Waiting for next frame in pair') time.sleep(delayshort) print('Waiting for next iterations') time.sleep(delaylong) return tt
def diffPiston(image): ''' Parameters ---------- image: masked array image for the analysis Returns ------- diff_piston: numpy masked array ''' dimx = image.shape[0] dimy = image.shape[1] imas = image[:, 0:np.int(dimy / 2)] imad = image[np.int(dimx / 2):, :] coefs, mat = zernike.zernikeFit(imas, np.arange(3) + 1) coefd, mat = zernike.zernikeFit(imad, np.arange(3) + 1) diff_piston = coefs[0] - coefd[1] return diff_piston
def tipTiltDetrend(self, image, roi, final_index, analysis_ind=None): """ Parameters ---------- image: numpy masked array image to be analyzed roi: list roi of the image final_index: int index of final roi analysis_index: nunpy array index of roi to be used for the analysis Returns ------- image_ttr: numpy array image without tip and tilt """ roi_copy = np.copy(roi) self._logger.debug('Removal of tip-tilt from roi[%d]', final_index) self._totalMatList = [] coefList = [] for r in roi: if np.any(r == 0): imag = np.ma.masked_array(image.data, mask=r) ima = np.ma.MaskedArray.copy(imag) coef, mat = zernike.zernikeFit(ima, np.array([1, 2, 3])) self._totalMatList.append(mat[:, 1:]) coefList.append(coef) if analysis_ind is None: analysis_ind = np.array([1, 2]) #from roi #coef_list = coefList #del coef_list[final_index] else: analysis_ind = analysis_ind coef_list = [] for i in range(len(analysis_ind)): coef_list.append(coefList[analysis_ind[i]]) piston, tip, tilt = np.average(coef_list, axis=0) surfcoef = np.array([tip, tilt]) image_whit_tt = np.ma.masked_array(image.data, mask=roi[final_index]) zernike_surface_to_subtract = zernike.zernikeSurface( image_whit_tt, surfcoef, self._totalMatList[final_index]) image_ttr = image_whit_tt - zernike_surface_to_subtract return image_ttr
def _tipTiltCalculator(self, cube): coef_tilt_list = [] coef_tip_list = [] for i in range(cube.shape[2]): image = cube[:, :, i] coef, mat = zernike.zernikeFit(image, np.array([2, 3])) coef_tip_list.append(-coef[0] / (633e-9) * np.sqrt(2)) coef_tilt_list.append(coef[1] / (633e-9) * np.sqrt(2)) tip = np.array(coef_tip_list) tilt = np.array(coef_tilt_list) #devo diventare angoli #mettendo la maschera #fare il plot di tip, tilt (plot isometrico:stesse dimensioni x y) return tip, tilt
def _createInteractionMatrix(self, mask): coefList = [] self._cube = self.getCube() for i in range(self._cube.shape[2]): ima = np.ma.masked_array(self._cube[:, :, i], mask=mask) coef, mat = zernike.zernikeFit(ima, np.arange(10) + 1) # z= np.array([2,3,4,7,8]) z = np.array([1, 2, 3, 6, 7]) final_coef = np.zeros(z.shape[0]) final_coef = coef[z] self._mat = mat coefList.append(final_coef) self._intMat = np.zeros((coefList[0].shape[0], self._cube.shape[2])) for j in range(self._cube.shape[2]): self._intMat.T[j] = coefList[j]
def tiptilt_fit(ima): ''' Parameters ---------- image: masked array Returns ------- ima_ttr: numpy masked array image without tip and tilt ''' if ima is not None: coef, mat = zernike.zernikeFit(ima, np.array([2, 3])) surf = zernike.zernikeSurface(ima, coef, mat) new_image = ima - surf ima_ttr = np.ma.masked_array(new_image, mask=ima.mask) return ima_ttr
def opticalMonitoring(self, n_images, delay): ''' #monitora Parameters ---------- n_images: int number of images to acquire delay: int [s] waiting time (in seconds) between two image acquisitions Returns ------ tt: string tracking number of measurements ''' store_in_folder = fold_name.OPD_SERIES_ROOT_FOLDER dove, tt = tracking_number_folder.createFolderToStoreMeasurements( store_in_folder) zer_list = [] temp_list = [] t0 = time.time() for i in range(n_images): ti = time.time() dt = ti - t0 masked_ima = self._interf.acquire_phasemap(1) temp_vect = self._ott.temperature.getTemperature() name = Timestamp.now() + '.fits' fits_file_name = os.path.join(dove, name) pyfits.writeto(fits_file_name, masked_ima.data) pyfits.append(fits_file_name, masked_ima.mask.astype(int)) coef, mat = zernike.zernikeFit(masked_ima, np.arange(10) + 1) vect = np.append(dt, coef) zer_list.append(vect) temp_list.append(temp_vect) fits_file_name = os.path.join(dove, 'zernike.fits') pyfits.writeto(fits_file_name, np.array(zer_list), overwrite=True) fits_file_name = os.path.join(dove, 'temperature.fits') pyfits.writeto(fits_file_name, np.array(temp_list), overwrite=True) time.sleep(delay) return tt
def _rmsFromCube(self, cube_to_process): ''' Parameters ---------- cube_to_process: [pixel, pixel, number of imagescube] cube generated by the analyzer_iffunctions Returns ------- rms_mean: numpy array rms averaged on the number of modes used in the iff's acquisition tip: numpy array tip averaged on the number of modes used in the iff's acquisition tilt: numpy array tilt averaged on the number of modes used in the iff's acquisition ''' self._logger.debug('Calculation of rms, tip and tilt') rms_list = [] coef_tilt_list = [] coef_tip_list = [] quad_list = [] ptv_list = [] for i in range(cube_to_process.shape[2]): image = cube_to_process[:, :, i] coef, mat = zernike.zernikeFit(image, np.array([1, 2, 3])) sur = zernike.zernikeSurface(image, coef, mat) image_ttr = image - sur ptv = np.max(image_ttr) - np.min(image_ttr) ptv_list.append(ptv) rms = image_ttr.std() rms_list.append(rms) coef_tip_list.append(coef[1]) coef_tilt_list.append(coef[2]) quad = np.sqrt(coef[1]**2 + coef[2]**2) quad_list.append(quad) ptv_vector = np.array(ptv_list) rms_vector = np.array(rms_list) tip = np.array(coef_tip_list).mean() tilt = np.array(coef_tilt_list).mean() quad_tt = np.array(quad_list).mean() rms_mean = np.mean(rms_vector) ptv_mean = np.mean(ptv_vector) return rms_mean, quad_tt, tilt, ptv_mean
def validFrames(self): '''Create the plot of individual RMS of each frames (without tip/tilt) together with RMS of the average frame ''' rs_img = self._readRsImg() coef, mat = zernike.zernikeFit(rs_img, np.array([2, 3])) surf = zernike.zernikeSurface(rs_img, coef, mat) rs_ttr = rs_img - surf r0 = rs_ttr.std() cube_ttr = self._readCube(1) rs_vect = np.zeros(cube_ttr.shape[2]) for j in range(cube_ttr.shape[2]): rs_vect[j] = cube_ttr[:, :, j].std() plt.figure() plt.plot(np.arange(cube_ttr.shape[2]), rs_vect, label='Data'); plt.yscale('log') plt.plot(np.zeros(cube_ttr.shape[2]) + r0, label='Average') plt.ylabel('m RMS'); plt.xlabel('# frames') plt.title('Images WFE'); plt.legend()
def parTiltTest(self, act, val_vec): ''' Parameters ---------- act: int number of the actuator to move val_vec: int value to assignee to actuator Returns ------- quad: numpy array vector of rss coef: numpy array vector of zernike coefficients of image-difference image0: numpy masked array start image delta_list: list different from start image ''' image0 = self._interf.acquire_phasemap(10) delta_list = [] sum_list = [] coef_list = [] for i in range(val_vec.size): self._opc._setAct(act, val_vec[i]) image = self._interf.acquire_phasemap(10) delta = image - image0 delta_list.append(delta) coef, mat = zernike.zernikeFit(delta, np.arange(10) + 1) coef_list.append(coef) sum = np.sqrt(coef[1]**2 + coef[2]**2) sum_list.append(sum) quad = np.array(sum_list) plt.plot(val_vec, quad, '-o') return quad, np.array(coef_list), image0, delta_list
def alignTest(self, tt, n_images, perturbation_vec, pre=False): ''' Parameters --------- tt: string tracking number for the alignment n_images: int number of frames for the interferometer perturbation_vec: numpy array np.array([par_focus, par_tilt, par_tip]) Other Parameters ---------------- pre: boolean if True a pre-tiptilt alignment before the 5 dof one Returns ------- coeff_matrix: numpy array zernike coefficients matrix for all the images tt: string tracking number of measurements ''' # Homing the system self._ottca.par_and_rm_aligner(True, tt, n_images, np.array([0, 1]), np.array([3, 4])) #a.ott_alignment(n_images, 1, np.array([0,1]), np.array([3,4]), tt) par0 = self._ott.parabola.getPosition() rm0 = self._ott.referenceMirror.getPosition() # Set perturbation from perturbation_vec focus = perturbation_vec[0] tip = perturbation_vec[1] tilt = perturbation_vec[2] par1 = np.copy(par0) par1[2] += focus par1[3] += tip par1[4] += tilt rm1 = np.copy(rm0) rm1[3] += -tip * 2.05 rm1[4] += -tilt * 2.05 # Initialization zern_vec = np.arange(1, 12, 1) coeff = [] # Start image, perturbation and perturbed image image = self._interf.acquire_phasemap(n_images) pippo = zernike.zernikeFit(image, zern_vec) coeff.append(pippo[0]) self._ott.parabola.setPosition(par1) self._ott.referenceMirror.setPosition(rm1) image = self._interf.acquire_phasemap(n_images) pippo = zernike.zernikeFit(image, zern_vec) coeff.append(pippo[0]) # TipTilt pre-alignment if pre is True: self._ottca.par_and_rm_aligner(True, tt, n_images, np.array([0, 1]), np.array([3, 4])) #a.ott_alignment(n_images, 1, np.array([0,1]), np.array([3,4]), tt) image = self._interf.acquire_phasemap(2) pippo = zernike.zernikeFit(image, zern_vec) coeff.append(pippo[0]) # First alignment self._ottca.par_and_rm_aligner(True, tt, n_images, np.array([0, 1]), np.array([3, 4])) #a.ott_alignment(n_images, 1, np.array([0,1,2,3,4]), np.array([0,1,2,3,4]), tt) image = self._interf.acquire_phasemap(2) pippo = zernike.zernikeFit(image, zern_vec) coeff.append(pippo[0]) # Second alignment self._ottca.par_and_rm_aligner(True, tt, n_images, np.array([0, 1]), np.array([3, 4])) #a.ott_alignment(n_images, 1, np.array([0,1]), np.array([3,4]), tt) image = self._interf.acquire_phasemap(n_images) pippo = zernike.zernikeFit(image, zern_vec) coeff.append(pippo[0]) # Check image image = self._interf.acquire_phasemap(n_images) pippo = zernike.zernikeFit(image, zern_vec) coeff.append(pippo[0]) coeff_matrix = np.array(coeff) * 1e9 parend = self._ott.parabola.getPosition() store_in_folder = os.path.join(fold_name.REPEATABILITY_ROOT_FOLDER, 'Alignment') dove, tt = tracking_number_folder.createFolderToStoreMeasurements( store_in_folder) fits_file_name = os.path.join(dove, 'zernike.fits') pyfits.writeto(fits_file_name, coeff_matrix, overwrite=True) print(parend - par0) return coeff_matrix, tt
def analysis_whit_structure_function(self, data_file_path, tau_vector, h5_or_fits=None): ''' .. 4000 = total number of image in hdf5 Parameters ---------- data_file_path: string measurement data folder tau_vector: numpy array vector of tau to use Other Parameters ---------------- h5_or_fits: if it is none the h5 data analysis is performed Returns ------- rms_medio: numpy array calculated on the difference of the images (distant tau) quad_med: numpy array squaring sum of tip and tilt calculated on the difference of the images ''' if h5_or_fits is None: list = glob.glob(os.path.join(data_file_path, '*.h5')) else: listtot = glob.glob(os.path.join(data_file_path, '*.fits')) listtot.sort() list = listtot[0:-2] image_number = len(list) i_max = np.int((image_number - tau_vector[tau_vector.shape[0] - 1]) / (tau_vector[tau_vector.shape[0] - 1] * 2)) if i_max <= 10: raise OSError('tau = %s too large. i_max = %d' % (tau_vector[tau_vector.shape[0] - 1], i_max)) rms_medio_list = [] quad_med_list = [] for j in range(tau_vector.shape[0]): dist = tau_vector[j] print(dist) rms_list = [] quad_list = [] for i in range(i_max): k = i * dist * 2 if h5_or_fits is None: #k = i * dist * 2 name = 'img_%04d.h5' % k file_name = os.path.join(data_file_path, name) image_k = self._ic.from4D(file_name) name = 'img_%04d.h5' % (k + dist) file_name = os.path.join(data_file_path, name) image_dist = self._ic.from4D(file_name) else: image_k = read_data.readFits_maskedImage(list[k]) image_dist = read_data.readFits_maskedImage(list[k + dist]) image_diff = image_k - image_dist zernike_coeff_array, mat = zernike.zernikeFit( image_diff, np.array([2, 3])) sur = zernike.zernikeSurface(image_diff, zernike_coeff_array, mat) image_ttr = image_diff - sur quad = np.sqrt(zernike_coeff_array[0]**2 + zernike_coeff_array[1]**2) rms = image_ttr.std() rms_list.append(rms) quad_list.append(quad) rms_vector = np.array(rms_list) aa = rms_vector.mean() rms_medio_list.append(aa) quad_med_list.append(np.array(quad_list).mean()) rms_medio = np.array(rms_medio_list) quad_med = np.array(quad_med_list) # per calcolo statistical amplitude of convention n_meas = rms_vector.shape[0] * 2 * tau_vector.shape[0] return rms_medio, quad_med, n_meas
def parPistonTest(self, piston_value, deltapos_filepath, amp, tt_for_align): ''' Parameters ---------- piston_value: int relative value for the parab piston deltapos_filepath: string file path for par and rm delta positions amp: float tip tilt amplitude for par and rm tt_for_align: string tracking number for alignment Returns ------- tt: string tracking number of measurements ''' # '/home/m4/pardeltapos.fits' hduList = pyfits.open(deltapos_filepath) deltapos = hduList[0].data dx = deltapos[:, 0] * amp dy = deltapos[:, 1] * amp dove, tt = tracking_number_folder.createFolderToStoreMeasurements( fold_name.PISTON_TEST_ROOT_FOLDER) par0 = self._ott.parabola.getPosition() rm0 = self._ott.referenceMirror.getPosition() n_frames_meas = 10 n_frames_alignment = 3 rmcoeff = -2.04 coef_list = [] par_list = [] rm_list = [] for i in range(dx.size): if i == 0: print('Iteration 0') else: print('Iteration %d' % i) par_new = par0.copy() rm_new = rm0.copy() par_new[3] += dx[i] rm_new[3] += rmcoeff * dx[i] par_new[4] += dy[i] rm_new[4] += rmcoeff * dy[i] self._ott.parabola.setPosition(par_new) self._ott.referenceMirror.setPosition(rm_new) par_cmd, rm_cmd = self._ottca.par_and_rm_aligner( True, tt_for_align, n_frames_alignment, np.array([0, 1]), np.array([3, 4])) # a.ott_alignment(n_frames_alignment, 1, # np.array([0, 1]), # np.array([3, 4]), # tt_for_align) par = self._ott.parabola.getPosition() rm = self._ott.referenceMirror.getPosition() par_list.append(par) rm_list.append(rm) masked_ima0 = self._interf.acquire_phasemap(n_frames_meas) par[2] += piston_value self._ott.parabola.setPosition(par) masked_ima1 = self._interf.acquire_phasemap(n_frames_meas) par[2] -= piston_value self._ott.parabola.setPosition(par) diff = masked_ima1 - masked_ima0 name = 'diff_%04d.fits' % i self._interf.save_phasemap(dove, name, diff) coef, mat = zernike.zernikeFit(diff, np.arange(10) + 1) coef_list.append(coef) fits_file_name = os.path.join(dove, 'Zernike.fits') pyfits.writeto(fits_file_name, np.array(coef_list), overwrite=True) fits_file_name = os.path.join(dove, 'PAR_Positions.fits') pyfits.writeto(fits_file_name, np.array(par_list), overwrite=True) fits_file_name = os.path.join(dove, 'RM_Positions.fits') pyfits.writeto(fits_file_name, np.array(rm_list), overwrite=True) return tt
def robustImageFromDataSet(n_images, data_file_path, zernike_vector_to_subtract, offset=None): ''' From fits files and whit offset subtraction Parameters ---------- n_images: int number of images to analyze path: string total path for data analysis Other Parameters ---------------- offset: if it is None data analysis is made by split n_images in two else re-reads the offset image saved in the tt folder and subtracts it to each image during cube creation Returns ------- robust_image: numpy masked array robust image from data set ''' last_name = data_file_path.split('/')[-1] if last_name == 'hdf5': list_tot = glob.glob(os.path.join(data_file_path, '*.h5')) tt = data_file_path.split('/')[-2] ext = 1 else: list_tot = glob.glob(os.path.join(data_file_path, '*.fits')) tt = data_file_path.split('/')[-1] ext = 0 list_tot.sort() list = list_tot[0:n_images] if offset is None: half = np.int(len(list) / 2) list1 = list[0:half] list2 = list[half:] cube1 = None print('Creating cube 1') for name in list1: #print(name) image = read_data.read_phasemap(name, ext) if cube1 is None: cube1 = image else: cube1 = np.ma.dstack((cube1, image)) cube2 = None print('Creating cube 2') for name in list2: #print(name) image = read_data.read_phasemap(name, ext) if cube2 is None: cube2 = image else: cube2 = np.ma.dstack((cube1, image)) mean1 = np.ma.mean(cube1, axis=2) mean2 = np.ma.mean(cube2, axis=2) final_image = mean2 - mean1 else: fits_file_name = os.path.join(config.OUT_FOLDER, 'Req', tt, 'OptOffset.fits') image_optOffset = read_data.readFits_maskedImage(fits_file_name) cube = None print('Creating cube') for name in list: #print(name) ima = read_data.read_phasemap(name, ext) image = ima - image_optOffset if cube is None: cube = image else: cube = np.ma.dstack((cube, image)) final_image = np.ma.mean(cube, axis=2) coef, mat = zernike.zernikeFit(final_image, zernike_vector_to_subtract) surf = zernike.zernikeSurface(final_image, coef, mat) image_ttr = final_image - surf return image_ttr
def scanAstigmComa(self, stepamp, nstep, nframes=10): # by RB 20210117. ''' Parameters ---------- stepamp: int amplitude for tip and tilt nstep: int number of step measurements nframes: int number of interferometr's frames Returns ------ tt: string tracking number of measurements ''' # goal: to measure coma and astigmatism at different PAR position, spanning 500 arcsec store_in_folder = fold_name.CALIBRATION_ROOT_FOLDER dove, tt = tracking_number_folder.createFolderToStoreMeasurements( store_in_folder) par2rm = -2.05 zern_vect = [] parpos = [] rmpos = [] par0 = self._ott.parabola.getPosition() rm0 = self._ott.referenceMirror.getPosition() n2move = np.array([3, 4]) thedirection = np.array([-1, 1]) n_frames_alignment = 3 tt_for_align = '20210111_152430' for k in n2move: for v in thedirection: for i in range(nstep): par1 = par0.copy() parmove = stepamp * i * v par1[k] += parmove print('Moving PAR[%d] by %d' % (k, parmove)) self._ott.parabola.setPosition(par1) rm1 = rm0.copy() rmmove = stepamp * i * v * par2rm rm1[k] += rmmove self._ott.referenceMirror.setPosition(rm1) print('Moving RM[%d] by %d' % (k, rmmove)) par_cmd, rm_cmd = self._ottca.par_and_rm_aligner( True, tt_for_align, n_frames_alignment, np.array([0, 1]), np.array([3, 4])) # a.ott_alignment(n_frames_alignment, 1, # np.array([0, 1]), # np.array([3, 4]), # tt_for_align) par2 = self._ott.parabola.getPosition() rm2 = self._ott.referenceMirror.getPosition() masked_ima = self._interf.acquire_phasemap(nframes) name = Timestamp.now() + '.fits' fits_file_name = os.path.join(dove, name) pyfits.writeto(fits_file_name, masked_ima.data) pyfits.append(fits_file_name, masked_ima.mask.astype(int)) coef, mat = zernike.zernikeFit(masked_ima, np.arange(10) + 1) zern_vect.append(coef) parpos.append(par2) rmpos.append(rm2) fits_file_name = os.path.join(dove, 'zernike.fits') pyfits.writeto(fits_file_name, np.array(zern_vect), overwrite=True) fits_file_name = os.path.join(dove, 'PAR_positions.fits') pyfits.writeto(fits_file_name, np.array(parpos), overwrite=True) fits_file_name = os.path.join(dove, 'RM_positions.fits') pyfits.writeto(fits_file_name, np.array(rmpos), overwrite=True) self._ott.parabola.setPosition(par0) self._ott.referenceMirror.setPosition(rm0) return tt