def PT_calibration(n_meas): ''' Parameters ---------- n_meas: int number of measurement to store Returns ------- dove: string data file path of measurement ''' from m4.ground import tracking_number_folder from opcua import Client server = OpcUaParameters.server client = Client(url=server) client.connect() folder = config.PT_ROOT_FOLDER dove, tt = tracking_number_folder.createFolderToStoreMeasurements(folder) for i in range(n_meas): time.sleep(2) temp = client.get_node("ns=7;s=MAIN.i_Temperature_Sensor") temp_list = temp.get_value() temp_vector = np.array(temp_list.get_value()) fits_file_name = os.path.join(dove, 'temperature_%04.fits' % i) pyfits.writeto(fits_file_name, temp_vector) print('Misura %04d' % i) return dove
def saveInfo(self, fits_or_h5): """ Save the data in fits format Returns ------- tt: string tracking number """ store_in_folder = CmdHistory._storageFolder() dove, tt = tracking_number_folder.createFolderToStoreMeasurements( store_in_folder) if fits_or_h5 == 0: fits_file_name = os.path.join(dove, 'info.fits') header = pyfits.Header() header['NPUSHPUL'] = self._nPushPull pyfits.writeto(fits_file_name, self._modeVector, header) pyfits.append(fits_file_name, self._indexingList, header) pyfits.append(fits_file_name, self._cmdMatrix, header) pyfits.append(fits_file_name, self._cmdHToApply, header) pyfits.append(fits_file_name, self._ampVect, header) else: fits_file_name = os.path.join(dove, 'info.h5') hf = h5py.File(fits_file_name, 'w') hf.create_dataset('dataset_1', data=self._modeVector) hf.create_dataset('dataset_2', data=self._indexingList) hf.create_dataset('dataset_3', data=self._cmdHToApply) hf.create_dataset('dataset_4', data=self._ampVect) hf.attrs['NPUSHPUL'] = self._nPushPull hf.close() return tt
def measureAndAnalysisCalibrationMatrix(self, who, command_amp_vector, n_push_pull, n_frames): ''' Parameters ---------- who: string string indicating the optical element on which to perform the calibration cal.WHO_PAR_AND_RM for parabola and reference mirror cal.WHO_PARABLE for parabola (non implemented) cal.WHO_RM for reference mirror (not implemented) cal.WHO_M4 for deformable mirror command_amp_vector: numpy array [mm] vector containing the amplitude of the commands to give degrees of freedom to calibrate n_push_pull: int number of push pull n_frames: int number of frame for 4D measurement Returns ------- tt : string tracking number containing measurements and IntMat from analysis ''' self._nPushPull = n_push_pull self._commandAmpVector = command_amp_vector dove, self.tt = tracking_number_folder.createFolderToStoreMeasurements( self._storageFolder()) self._logger.info('Measure of calibration. Location: %s', self.tt) #measurement dofIndex_vector = self._logAndDefineDovIndexForCommandMatrixCreation( who) self._commandMatrix, self._commandList = self.createCmatAndCmdList( command_amp_vector, dofIndex_vector) self._measureAndStore(self._commandList, dove, n_frames) #analysis self._createCube(False) # cubo non normalizzato cube = self.getCube() self._mask = self._findMask(cube) self._intMat = self.getInteractionMatrix() self._saveCalibrationInfoAndResultsAsFits(dove) # if self._mixed_method == False: # self._createCube() #cubo normalizzato # cube_norm = self.getCube() # self._mask = self._findMask(cube_norm) # self._intMatNorm = self.getInteractionMatrix(self._mask) # fits_file_name = os.path.join(dove, 'InteractionMatrixNorm.fits') # pyfits.writeto(fits_file_name, self._intMatNorm, overwrite=True) return self.tt
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 save(self): """ Function to save the info file """ store_in_folder = Flattenig._storageFolder() dove, tt = tracking_number_folder.createFolderToStoreMeasurements( store_in_folder) fits_file_name = os.path.join(dove, 'info.fits') header = pyfits.Header() header['WHO'] = self._who pyfits.writeto(fits_file_name, self._command, header) pyfits.append(fits_file_name, self._flatteningWf.data, header) pyfits.append(fits_file_name, self._flatteningWf.mask.astype(int), header) return tt
def image_acquisition(self, start_point, end_point, n_points): """ Parameters ---------- start_point: int [deg] absolute position in deg for the value of start angle end_point: int [deg] absolute position in deg for the value of end angle n_points:int number of images desired Returns ------- tt: string tracking number of measurements """ self._logger.info('Images acquisition') dove, self.tt = tracking_number_folder.createFolderToStoreMeasurements( RotOptAlign._storageFolder()) total_angle = np.abs(end_point - start_point) / 1. self._ott.angleRotator.setPosition(start_point) rot_angle = total_angle / n_points number_of_image = np.int(total_angle / rot_angle) angle_list = [] self._cube = None start_angle = self._ott.angleRotator.getPosition() if end_point < start_point: direction = -1 elif end_point > start_point: direction = 1 for k in range(number_of_image + 1): #start_angle = self.ott.angle() self._ott.angleRotator.setPosition(start_angle + k * rot_angle * direction) angle_list.append(start_angle + k * rot_angle * direction) time.sleep(5) masked_ima = self._interf.acquire_phasemap(1) name = 'Frame_%04d.fits' % k self._interf.save_phasemap(dove, name, masked_ima) if self._cube is None: self._cube = masked_ima else: self._cube = np.ma.dstack((self._cube, masked_ima)) self._saveCube(dove) self._angles = angle_list self._saveAngles(self._angles, self.tt) return self.tt
def noise_analysis_from_hdf5_folder(self, data_file_path, tidy_or_shuffle, template, n_push_pull=None, actsVector=None): ''' Parameters ---------- data_file_path: string measurement data folder tidy_or_shuffle: int 0 for tidy, 1 for shuffle template: numpy array vector composed by 1 and -1 Other Parameters ---------------- actsVector: numpy array, optional vector of actuators or modes n_push_pull: int number of push pull Returns ------- tt: string tracking number of measurements made ''' an = self._defAnalyzer(data_file_path, tidy_or_shuffle, template, actsVector, n_push_pull) dove, tt = tracking_number_folder.createFolderToStoreMeasurements( self._storageFolder()) self._logger.info('Creating analysis in %s', tt) self._cubeFromAnalysis = an.createCubeFromImageFolder(data_file_path) fits_file_name = os.path.join(dove, 'Cube.fits') pyfits.writeto(fits_file_name, self._cubeFromAnalysis.data) pyfits.append(fits_file_name, self._cubeFromAnalysis.mask.astype(int)) self._saveInfo(dove, tidy_or_shuffle, an._template, an._actsVector, an._nPushPull) rms_mean, quad_mean, tilt_mean, ptv_mean = self._rmsFromCube( self._cubeFromAnalysis) self._saveResults(rms_mean, quad_mean, ptv_mean, dove) return tt
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 testTtFolder(self): store_in_folder = '?' dove, tt = tracking_number_folder.createFolderToStoreMeasurements( store_in_folder)
def acquire(self, lambda_vector, exptime=0.7, mask=None): ''' Parameters ---------- lambda_vector: numpy array vector of wavelengths (between 400/700 nm) Other Parameters ---------------- exptime: float best exposure time for camera for laboratory conditions mask: numpy array mask for measurements Returns ------- tt: string tracking number of measurements ''' self._dove, tt = tracking_number_folder.createFolderToStoreMeasurements( self._storageFolder()) fits_file_name = os.path.join(self._dove, 'lambda_vector.fits') pyfits.writeto(fits_file_name, lambda_vector) ## find PSF position ## print('Acquiring reference image at 600 nm...') self._filter.set_wl(600) self._camera.feature('ExposureTimeAbs').value = 1.5 * exptime * 1e6 img = self._camera.acquire_frame(30 * 1000).buffer_data_numpy() if mask is None: mask = np.zeros(img.shape) reference_image = np.ma.masked_array(img, mask) if np.max(reference_image) > 4000: print("**************** WARNING: saturation detected!") # calcolo il baricentro cy, cx = self._baricenterCalculator(reference_image) expgain = np.ones(lambda_vector.shape[0]) expgain[np.where(lambda_vector < 500)] = 8 expgain[np.where(lambda_vector < 530)] = 4 expgain[np.where(lambda_vector > 680)] = 3 expgain[np.where(lambda_vector > 700)] = 8 expgain[np.where(lambda_vector >= 720)] = 9 self._logger.info('Acquisition of frames') for wl, expg in zip(lambda_vector, expgain): print('Acquiring image at %d nm...' % wl) self._filter.set_wl(wl) self._camera.feature( 'ExposureTimeAbs').value = exptime * expg * 1e6 #time.sleep(3 * ExposureTimeAbs / 1e6) image = self._camera.acquire_frame(30 * 1000).buffer_data_numpy() image = np.ma.masked_array(image, mask) # plot(image) #plt.imshow(image) #plt.show() crop = self._preProcessing(image, cy, cx) crop_rot = scin.rotate(crop, 23, reshape=False) #plt.figure(figsize=(10,5)) self.plot2(crop, crop_rot) file_name = 'image_%dnm.fits' % wl self._saveCameraFrame(file_name, crop) print('Saved tracking number:', tt) return tt
def acq_IFFunctions(self, n_push_pull, amplitude_fits_file_name, cmd_matrix_fits_file_name, shuffle=None, template=None): ''' Performs the process of acquiring interferograms Parameters ---------- n_push_pull: int number of push pull on the actuator amplitude_fits_file_name: string fits file name (Example = amp.fits) cmd_matrix_fits_file_name: int fits file name (Example = modalBase.fits) Other Parameters ---------------- shuffle: optional if not indicated, the function create the tidy command history matrix template: numpy array, optional vector composed by 1 and -1 if not indicated, the function create the vector [1, -1, 1] Returns ------- tt: string tracking number of measurements made ''' amplitude, cmd_matrix = self._readTypeFromFitsNameTag( amplitude_fits_file_name, cmd_matrix_fits_file_name) self._nPushPull = n_push_pull if template is None: self._template = np.array([1, -1, 1]) else: self._template = template self._amplitudeTag = amplitude_fits_file_name self._amplitude = amplitude self._cmdMatrixTag = cmd_matrix_fits_file_name self._cmdMatrix = cmd_matrix self._actsVector = np.arange(self._nActs) indexing_input = copy.copy(self._actsVector) dove, tt = tracking_number_folder.createFolderToStoreMeasurements( self._storageFolder()) self._tt = tt # diagonal_mat = self._diagonalControll(cmd_matrix) # if np.count_nonzero(diagonal_mat - # np.diag(np.diagonal(diagonal_mat))) == 0: # print('Measure of zonal IF') # self._logger.info("Measurement of zonal influence functions for segment?. Location: %s", # tt) # else: # print('Measure of global IF') # self._logger.info("Measurement of modal influence functions for segment?. Location: %s", # tt) cmdH = CmdHistory(self._nActs) if shuffle is False: command_history_matrix_to_apply, self._tt_cmdH = \ cmdH.tidyCommandHistoryMaker(self._actsVector, amplitude, cmd_matrix, n_push_pull, template) if shuffle is True: command_history_matrix_to_apply, self._tt_cmdH = \ cmdH.shuffleCommandHistoryMaker(self._actsVector, amplitude, cmd_matrix, n_push_pull, template) self._indexingList = cmdH.getIndexingList() #self._saveInfo(dove, 0) #self._saveInfoSeparately(dove) n_images = 1 for i in range(command_history_matrix_to_apply.shape[1]): for j in range(self._template.shape[0]): k = self._template.shape[0] * i + j print('Acquisition of image %d' % k) self._dm.setActsCommand(command_history_matrix_to_apply[:, i] * j) #vecchia setShape masked_image = self._interf.acquire_phasemap(n_images) file_name = 'image_%04d.fits' % k self._interf.save_phasemap(dove, file_name, masked_image) return tt
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
def rawAcquisition(self, numberOfFrames): dove, tt = tracking_number_folder.createFolderToStoreMeasurements( self._rawFramesDirectory) self._interf.burstFramesToSpecificDirectory(dove, numberOfFrames) return tt
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 mappingPar(self, shift, n_iter, tt_for_align): ''' Parameters ---------- shift: numpy array np.array([shift_par, shift_rm, rot_angle]) n_iter: int number of iterations tt_for_align: string tracking number for alignment Returns ------- tt: string tracking number of measurements ''' n_frames_alignment = 1 par0 = self._ott.parabola.getPosition() rm0 = self._ott.referenceMirror.getPosition() delta_par = [] delta_rm = [] delta_object = [] delta_object2 = [] delta_object3 = [] dove, tt = tracking_number_folder.createFolderToStoreMeasurements( fold_name.MAPPING_TEST_ROOT_FOLDER) if shift[2] != 0: shift[0] = shift[1] = 0 object_to_move = 'ANGLE' if shift[1] != 0: shift[0] = shift[2] = 0 object_to_move = 'RM' if shift[0] != 0: shift[1] = shift[0] shift[2] = 0 object_to_move = 'PAR + RM' file = open(os.path.join(dove, 'MappingInfo.txt'), "a") file.write('Mapping object: ' + object_to_move + '\n') file.close() slide0 = self._ott.parabolaSlider.getPosition() rslide0 = self._ott.referenceMirrorSlider.getPosition() angle0 = self._ott.angleRotator.getPosition() slide = -1 rslide = -1 angle = -1 for i in range(n_iter): if shift[0] != 0: slide = self._ott.parabolaSlider.setPosition(slide0 + ( (i + 1) * shift[0])) # if slide==0: # raise Exception('HOMING! PAR WIN') if shift[1] != 0: rslide = self._ott.referenceMirrorSlider.setPosition( rslide0 + ((i + 1) * shift[1])) # if rslide==0: # raise Exception('HOMING! RM WIN') if shift[2] != 0: angle = self._ott.angleRotator.setPosition(angle0 + ( (i + 1) * shift[2])) time.sleep(5) 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) image = self._interf.acquire_phasemap(1) name = 'image_%04d.fits' % i self._interf.save_phasemap(dove, name, image) par = self._ott.parabola.getPosition() rm = self._ott.referenceMirror.getPosition() delta_par.append(par - par0) delta_rm.append(rm - rm0) delta_object.append(slide - slide0) delta_object2.append(rslide - rslide0) delta_object3.append(angle - angle0) fits_file_name = os.path.join(dove, 'delta_slide.fits') pyfits.writeto(fits_file_name, np.array(delta_object), overwrite=True) fits_file_name = os.path.join(dove, 'delta_rslide.fits') pyfits.writeto(fits_file_name, np.array(delta_object2), overwrite=True) fits_file_name = os.path.join(dove, 'delta_PAR_positions.fits') pyfits.writeto(fits_file_name, np.array(delta_par), overwrite=True) fits_file_name = os.path.join(dove, 'delta_RM_positions.fits') pyfits.writeto(fits_file_name, np.array(delta_rm), overwrite=True) fits_file_name = os.path.join(dove, 'delta_ANGLE_positions.fits') pyfits.writeto(fits_file_name, np.array(delta_object3), overwrite=True) return tt
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 zernikeCommandTest(self, zernike_modes_vector_amplitude): ''' Parameters ---------- zernike_modes_vector_amplitude: numpy array vector of amplitude of zernike modes to be test, starting from z=2 Returns ------- tt: string tracking number for the measurement zernikeSurfaceCube: numpy array [512, 512, n_modes] all zernike surface generated on M4 m4ImagesCube: numpy array [512, 512, n_modes] cube consisting of the 6 images of the segments ''' self._ampVector = zernike_modes_vector_amplitude self._dove, self._tt = tracking_number_folder.createFolderToStoreMeasurements(self._storageFolder()) self._saveMeasurementInfo() self._logger.debug('Info file creation') self._logger.info('Creation of an list') for tt in self._ttListForAn: an = self._createAnalyzer(tt) self._anList.append(an) self._nModes = zernike_modes_vector_amplitude.shape[0] for j in range(self._nModes): amp = zernike_modes_vector_amplitude[j] if amp == 0: pass else: zernike_coeff_array = np.zeros(zernike_modes_vector_amplitude.shape[0]) zernike_coeff_array[j] = amp number_of_zernike_mode = j + 2 surface_map, total_mode_command = self.singleZernikeCommandTest(zernike_coeff_array, self._anList, number_of_zernike_mode) if self._zernikeSurfaceCube is None: self._zernikeSurfaceCube = surface_map else: self._zernikeSurfaceCube = np.dstack((self._zernikeSurfaceCube, surface_map)) #single_zernike_cube = self._singleZernikeModeCubeMeasurementCreator(number_of_zernike_mode) single_zernike_cube = self._TESTFUCTIONFORZERNIKECUBE(number_of_zernike_mode, amp) cube_name = 'cube_mode%04d.fits' %number_of_zernike_mode self._saveSingleZernikeCube(single_zernike_cube, cube_name) total_mode_image = self._imageReconstructor(single_zernike_cube) piston = self._differentialPistonMeasurement(total_mode_command) final_total_mode_image = total_mode_image - piston if self._m4ImagesCube is None: self._m4ImagesCube = final_total_mode_image else: self._m4ImagesCube = np.ma.dstack((self._m4ImagesCube, final_total_mode_image)) fits_file_name = os.path.join(self._dove, 'surfCube.fits') pyfits.writeto(fits_file_name, self._zernikeSurfaceCube) fits_file_name = os.path.join(self._dove, 'm4ImageCube.fits') pyfits.writeto(fits_file_name, self._m4ImagesCube.data) pyfits.append(fits_file_name, self._m4ImagesCube.mask.astype(int)) return self._tt, self._zernikeSurfaceCube, self._m4ImagesCube
def actsRepeatability(self, n_meas, piston_value, n_frames): ''' Parameters ---------- n_meas: int number of measurement for the test piston_value: float relative value for the parab piston n_frames: int number of frames for the acquisition measurement Returns ------ tt: string tracking number of measurements ''' store_in_folder = fold_name.REPEATABILITY_ROOT_FOLDER dove, tt = tracking_number_folder.createFolderToStoreMeasurements( store_in_folder) piston = np.array([0, 0, piston_value, 0, 0, 0]) pos_par = self._ott.parabola.getPosition() pos_rm = self._ott.referenceMirror.getPosition() par_list = [] rm_list = [] cube = None for i in range(n_meas): self._ott.parabola.setPosition(pos_par) self._ott.referenceMirror.setPosition(pos_rm) par0 = self._readActs(OpcUaParameters.PAR1, OpcUaParameters.PAR2, OpcUaParameters.PAR3) rm0 = self._readActs(OpcUaParameters.RM1, OpcUaParameters.RM2, OpcUaParameters.RM3) masked_ima0 = self._interf.acquire_phasemap(n_frames) self._ott.parabola.setPosition(pos_par + piston) # ott.refflat(pos_rm + piston) par1 = self._readActs(OpcUaParameters.PAR1, OpcUaParameters.PAR2, OpcUaParameters.PAR3) rm1 = self._readActs(OpcUaParameters.RM1, OpcUaParameters.RM2, OpcUaParameters.RM3) masked_ima1 = self._interf.acquire_phasemap(n_frames) self._ott.parabola.setPosition(pos_par - piston) # ott.refflat(pos_rm - piston) par2 = self._readActs(OpcUaParameters.PAR1, OpcUaParameters.PAR2, OpcUaParameters.PAR3) rm2 = self._readActs(OpcUaParameters.RM1, OpcUaParameters.RM2, OpcUaParameters.RM3) masked_ima2 = self._interf.acquire_phasemap(n_frames) par = np.array([par0, par1, par2]) rm = np.array([rm0, rm1, rm2]) cubetto = np.ma.dstack((masked_ima0, masked_ima1, masked_ima2)) if cube is None: cube = cubetto else: cube = np.ma.dstack((cube, cubetto)) par_list.append(par) rm_list.append(rm) pyfits.writeto(os.path.join(dove, 'par.fits'), np.array(par_list), overwrite=True) pyfits.writeto(os.path.join(dove, 'rm.fits'), np.array(rm_list), overwrite=True) pyfits.writeto(os.path.join(dove, 'images.fits'), cube.data, overwrite=True) pyfits.append(os.path.join(dove, 'images.fits'), cube.mask.astype(int), overwrite=True) self._ott.parabola.setPosition(pos_par) self._ott.referenceMirror.setPosition(pos_rm) return tt