if __name__=='__main__':
n_subap = numpy.array([36,36])
nx_subap = numpy.array([7, 7])
obs_diam = 1.
tel_diam = 4.2
n_wfs = 2
cents = fits.getdata('testFitsFiles/canary_nl0_h0m_it10k_r00p1_L025m_gspos0cn20a0c20.fits')
pupil_mask = make_pupil_mask('circle', n_subap, nx_subap[0], obs_diam, tel_diam)
matrix_region_ones = numpy.ones(n_subap)
mm, mmc, md = get_mappingMatrix(pupil_mask, matrix_region_ones)
mat_f = cross_cov(cents)
cov_map = covMap_fromMatrix(mat_f, n_wfs, nx_subap, n_subap, pupil_mask, 'x and y', mm, mmc, md)
pyplot.figure('fresh')
pyplot.imshow(cov_map)
pyplot.figure('fresh xx')
pyplot.plot(numpy.arange(-6,7), cov_map[:, 19]/cov_map[:, 19].max())
t, tt_matrix = remove_tt_cents(cents, numpy.array([36, 36]),2)
mat = cross_cov(t)
cov_map = covMap_fromMatrix(mat, n_wfs, nx_subap, n_subap, pupil_mask, 'x and y', mm, mmc, md)
pyplot.figure('removed')
pyplot.imshow(cov_map)
pyplot.figure('removed xx')
pyplot.plot(numpy.arange(-6,7), cov_map[:, 19]/cov_map[:, 19].max())
def temporal_offset_roi(self):
print(
'\n' +
'###########################################################',
'\n')
print('########### PROCESSING SHWFS CENTROID OFFSETS #############',
'\n')
if self.l3s_wind == False:
num_arrays = 1
cents_array = numpy.zeros(
(num_arrays, self.shwfs_centroids.shape[0],
self.shwfs_centroids.shape[1]))
else:
num_arrays = 2
cents_array = numpy.zeros(
(num_arrays, self.shwfs_centroids.shape[0],
self.shwfs_centroids.shape[1]))
cents_array[1] = numpy.matmul(
numpy.matmul(self.l3s1_matrix, self.shwfs_centroids.T).T,
self.l3s1_matrix.T)
cents_array[0] = self.shwfs_centroids
roi_width = int(2 * self.wind_roi_envelope + 1)
width = int((2 * self.wind_roi_envelope + 1) * self.combs)
if self.wind_map_axis == 'x and y':
length = int(self.wind_roi_belowGround +
self.pupil_mask.shape[0]) * 2
else:
length = int(self.wind_roi_belowGround + self.pupil_mask.shape[0])
if self.separate_pos_neg_offsets == True:
roi_offsets = numpy.zeros((num_arrays, width, 2 * length))
else:
roi_offsets = numpy.zeros((num_arrays, width, length))
counter = 1
for n_a in range(num_arrays):
#loop over how many temporal offsets are being included in the fitting procedure
for dt in range(1, 1 + self.num_offsets):
#loop over number of GS combinations
for comb in range(self.combs):
percent_complete = counter / (
num_arrays * self.num_offsets * self.combs)
print(
'########################### ' + "%.2f" %
(percent_complete) + ' ##########################',
'\n')
# print('########################### '+str(counter)+'/'+str(num_arrays*self.num_offsets*self.combs)+' ###########################','\n')
counter += 1
#induce positive and negative temporal slope offsets
cents_zero_offset, cents_pos_offset, cents_neg_offset = self.temp_offset_cents(
cents_array[n_a], dt, self.temporal_step,
self.n_subap_from_pupilMask[self.selector[comb, 0]],
self.n_subap_from_pupilMask[self.selector[comb, 1]],
self.selector[comb])
#calculate roi directly from centroids or via matrix (for AOF via matrix is the fastest technique)
if self.roi_via_matrix == True:
comb_mat_pos = cross_cov(cents_pos_offset)
comb_map_pos = covMap_fromMatrix(
comb_mat_pos, 2, self.nx_subap[:2],
self.n_subap_from_pupilMask[:2], self.pupil_mask,
self.wind_map_axis, self.mm, self.mmc, self.md)
comb_roi_pos = roi_from_map(
comb_map_pos, self.gs_pos[self.selector[comb]],
self.pupil_mask, self.selector[:1],
self.wind_roi_belowGround, self.wind_roi_envelope)
comb_mat_neg = cross_cov(cents_neg_offset)
comb_map_neg = covMap_fromMatrix(
comb_mat_neg, 2, self.nx_subap[:2],
self.n_subap_from_pupilMask[:2], self.pupil_mask,
self.wind_map_axis, self.mm, self.mmc, self.md)
comb_roi_neg = roi_from_map(
comb_map_neg, self.gs_pos[self.selector[comb]],
self.pupil_mask, self.selector[:1],
self.wind_roi_belowGround, self.wind_roi_envelope)
if self.include_temp0 == True:
comb_mat_zero = cross_cov(cents_zero_offset)
comb_map_zero = covMap_fromMatrix(
comb_mat_zero, 2, self.nx_subap[:2],
self.n_subap_from_pupilMask[:2],
self.pupil_mask, self.wind_map_axis, self.mm,
self.mmc, self.md)
comb_roi_zero = roi_from_map(
comb_map_zero,
self.gs_pos[self.selector[comb]],
self.pupil_mask, self.selector[:1],
self.wind_roi_belowGround,
self.wind_roi_envelope)
comb_roi_pos += comb_roi_zero
comb_roi_neg += comb_roi_zero
if self.roi_via_matrix == False:
comb_roi_pos, time_pos = calculate_roi_covariance(
cents_pos_offset, self.gs_pos[self.selector[comb]],
self.pupil_mask, self.tel_diam,
self.wind_roi_belowGround, self.wind_roi_envelope,
self.wind_map_axis, self.wind_mapping_type)
comb_roi_neg, time_neg = calculate_roi_covariance(
cents_neg_offset, self.gs_pos[self.selector[comb]],
self.pupil_mask, self.tel_diam,
self.wind_roi_belowGround, self.wind_roi_envelope,
self.wind_map_axis, self.wind_mapping_type)
if self.include_temp0 == True:
comb_roi_zero, time_neg = calculate_roi_covariance(
cents_zero_offset,
self.gs_pos[self.selector[comb]],
self.pupil_mask, self.tel_diam,
self.wind_roi_belowGround,
self.wind_roi_envelope, self.wind_map_axis,
self.wind_mapping_type)
comb_roi_pos += comb_roi_zero
comb_roi_neg += comb_roi_zero
comb_roi_neg *= self.mult_neg_offset
if self.separate_pos_neg_offsets == True:
roi_offsets[n_a, comb * roi_width:(comb + 1) *
roi_width, :length] += comb_roi_neg
roi_offsets[n_a,
comb * roi_width:(comb + 1) * roi_width,
length:] += comb_roi_pos
else:
roi_offsets[n_a, comb * roi_width:(comb + 1) *
roi_width] += comb_roi_neg + comb_roi_pos
# if self.include_temp0==True:
# if self.roi_via_matrix==False:
# roi_temp0, time_temp0 = calculate_roi_covariance(cents_array[n_a],
# self.gs_pos, self.pupil_mask, self.tel_diam, self.wind_roi_belowGround,
# self.wind_roi_envelope, self.wind_map_axis, self.wind_mapping_type)
# if self.roi_via_matrix==True:
# mat_temp0 = cross_cov(cents_array[n_a])
# map_temp0 = covMap_fromMatrix(mat_temp0, self.n_wfs, self.nx_subap, self.n_subap_from_pupilMask,
# self.pupil_mask, self.wind_map_axis, self.mm, self.mmc, self.md)
# roi_temp0 = roi_from_map(map_temp0, self.gs_pos, self.pupil_mask, self.selector,
# self.wind_roi_belowGround, self.wind_roi_envelope)
# if self.separate_pos_neg_offsets==True:
# roi_offsets[n_a, :, :length] += roi_temp0 * self.mult_neg_offset
# roi_offsets[n_a, :, length:] += roi_temp0
# else:
# roi_offsets[n_a] += roi_temp0
if self.zeroSep_cov == False:
if self.separate_pos_neg_offsets == True:
roi_offsets[n_a, :, :length][self.zeroSep_locations] = 0.
roi_offsets[n_a, :, length:][self.zeroSep_locations] = 0.
else:
roi_offsets[n_a][self.zeroSep_locations] = 0.
del cents_array
return roi_offsets
def cov_fit_fromParams(self, covSliceParams, layer_alt, r0, tt_track, lgs_track, L0,
groundL0, globalL0, shwfs_shift, shwfs_rot):
#Make parameters guess values
np = 0
layer_alt = layer_alt.copy()
for i, val in enumerate(layer_alt):
if val==None:
layer_alt[i] = numpy.abs(covSliceParams[np])
np+=1
r0 = r0.copy()
for i, val in enumerate(r0):
if val==None:
r0[i] = numpy.abs(covSliceParams[np])
np+=1
L0 = L0.copy()
for i, val in enumerate(L0):
if val==None:
L0[i] = numpy.abs(covSliceParams[np])
np+=1
groundL0 = groundL0.copy()
for i, val in enumerate(groundL0):
if val==None:
groundL0[i] = numpy.abs(covSliceParams[np])
np+=1
globalL0 = globalL0.copy()
for i, val in enumerate(globalL0):
if val==None:
globalL0[i] = numpy.abs(covSliceParams[np])
np+=1
if self.fittingGroundL0==True:
L0[0] = numpy.array([groundL0]).flatten()[0]
if self.fittingGlobalL0==True:
L0 = numpy.array([globalL0]*len(r0)).flatten()
tt_track = tt_track.copy()
for i, val in enumerate(tt_track):
if val==None:
tt_track[i] = numpy.abs(covSliceParams[np])
np+=1
lgs_track = lgs_track.copy().reshape(2*self.gs_combs)
for i, val in enumerate(lgs_track):
if val==None:
lgs_track[i] = covSliceParams[np]
np+=1
lgs_track.resize(self.gs_combs, 2)
shwfs_shift = shwfs_shift.copy().reshape((2*len(shwfs_rot)))
for i, val in enumerate(shwfs_shift):
if val==None:
shwfs_shift[i] = covSliceParams[np]
np+=1
shwfs_shift.resize((len(shwfs_rot), 2))
shwfs_rot = shwfs_rot.copy()
for i, val in enumerate(shwfs_rot):
if val==None:
shwfs_rot[i] = covSliceParams[np]
np+=1
if self.method=='Direct Fit':
lgs_track = numpy.abs(lgs_track)
if self.target_array=='Covariance Map ROI':
if self.method=='Direct Fit':
covariance = self.generationParams._make_covariance_roi_(layer_alt.astype('float'),
r0.astype('float'), L0.astype('float'), tt_track=tt_track.astype('float'),
lgs_track=lgs_track.astype('float'), shwfs_shift=shwfs_shift.astype('float'),
shwfs_rot=shwfs_rot.astype('float'))
if self.method=='L3S Fit':
covariance = self.generationParams._make_covariance_roi_l3s_(layer_alt.astype('float'),
r0.astype('float'), L0.astype('float'), lgs_track=lgs_track.astype('float'),
shwfs_shift=shwfs_shift.astype('float'), shwfs_rot=shwfs_rot.astype('float'))
if self.zeroSep_cov==False:
covariance[self.zeroSep_locations] = 0.
else:
covariance = self.generationParams._make_covariance_matrix_(layer_alt.astype('float'),
r0.astype('float'), L0.astype('float'), tt_track=tt_track, lgs_track=lgs_track.astype('float'),
shwfs_shift=shwfs_shift.astype('float'), shwfs_rot=shwfs_rot.astype('float'))
if self.zeroSep_cov==False:
covariance[self.zeroSep_locations] = 0.
if self.target_array=='Covariance Map':
covariance = covMap_fromMatrix(covariance, self.n_wfs, self.nx_subap, self.n_subap_from_pupilMask,
self.pupil_mask, self.map_axis, self.mm, self.mmc, self.md)
self.count+=1
if self.print_fitting==True:
print("Iteration:", self.count)
print("Target Array:", self.target_array)
print("Method:", self.method)
print("Layer Distance:", layer_alt)
print("L0:", L0)
print("TT Track:", tt_track)
if self.using_lgs==True:
print("LGS Track:", lgs_track)
print("r0:", r0)
print("Shift: {}".format(shwfs_shift))
print("Rotation: {}".format(shwfs_rot))
self.r0 = r0.astype('float')
self.L0 = L0.astype('float')
self.tt_track = tt_track.astype('float')
self.lgs_track = lgs_track.astype('float')
self.shwfs_rot = shwfs_rot.astype('float')
self.shwfs_shift = shwfs_shift.astype('float')
# f, a = pyplot.subplots()
# a.set_title('$x_{1}x_{2} + y_{1}y_{2}$')
# a.set_xlabel('Sub-aperture Separation, $y$')
# a.set_yticks([])
# a.set_xticks(numpy.arange(0,9))
# a.set_xticklabels(numpy.arange(-1,8))
# im = a.imshow(covariance, vmin=0.002249661313233884, vmax=0.014974801906957418)
# pyplot.savefig('pngs_forVideos/turb_fit/turb'+str(self.count)+'.png', dpi=800)
return covariance
def cov_fit_fromParams(self, covSliceParams, r0, track, L0, groundL0,
globalL0, shwfs_shift, shwfs_rot):
#Make parameters guess values
np = 0
r0 = r0.copy()
for i, val in enumerate(r0):
if val == None:
r0[i] = numpy.abs(covSliceParams[np])
np += 1
L0 = L0.copy()
for i, val in enumerate(L0):
if val == None:
L0[i] = numpy.abs(covSliceParams[np])
np += 1
groundL0 = groundL0.copy()
for i, val in enumerate(groundL0):
if val == None:
groundL0[i] = numpy.abs(covSliceParams[np])
np += 1
globalL0 = globalL0.copy()
for i, val in enumerate(globalL0):
if val == None:
globalL0[i] = numpy.abs(covSliceParams[np])
np += 1
if self.fittingGroundL0 == True:
L0[0] = numpy.array([groundL0]).flatten()[0]
if self.fittingGlobalL0 == True:
L0 = numpy.array([globalL0] * self.n_layer).flatten()
track = track.copy()
for i, val in enumerate(track):
if val == None:
track[i] = numpy.abs(covSliceParams[np])
np += 1
shwfs_shift = shwfs_shift.copy().reshape((2 * self.n_wfs))
for i, val in enumerate(shwfs_shift):
if val == None:
shwfs_shift[i] = covSliceParams[np]
np += 1
shwfs_shift.resize((self.n_wfs, 2))
shwfs_rot = shwfs_rot.copy()
for i, val in enumerate(shwfs_rot):
if val == None:
shwfs_rot[i] = covSliceParams[np]
np += 1
# shwfs_rot = shwfs_rot.copy()
# for i, val in enumerate(shwfs_rot[1:]):
# if val==None:
# shwfs_rot[i+1] = covSliceParams[np]
# np+=1
# print(shwfs_rot)
if self.target_array == 'Covariance Map ROI':
if self.method == 'Direct Fit':
covariance = self.generationParams._make_covariance_roi_(
r0.astype('float'),
L0.astype('float'),
track=track.astype('float'),
shwfs_shift=shwfs_shift.astype('float'),
shwfs_rot=shwfs_rot.astype('float'))
if self.method == 'L3S Fit' or self.method == '2SL Fit':
covariance = self.generationParams._make_covariance_roi_l3s_(
r0.astype('float'), L0.astype('float'),
shwfs_shift.astype('float'), shwfs_rot.astype('float'))
if self.zeroSep_cov == False:
covariance[self.zeroSep_locations] = 0.
else:
covariance = self.generationParams._make_covariance_matrix_(
r0.astype('float'),
L0.astype('float'),
track=track,
shwfs_shift=shwfs_shift.astype('float'),
shwfs_rot=shwfs_rot.astype('float'))
if self.method == 'L3S Fit' or self.method == '2SL Fit':
covariance = numpy.matmul(
numpy.matmul(self.transform_matrix, covariance),
self.transform_matrix.T)
if self.zeroSep_cov == False:
covariance[self.zeroSep_locations] = 0.
if self.target_array == 'Covariance Map':
covariance = covMap_fromMatrix(covariance, self.n_wfs,
self.nx_subap, self.n_subap,
self.pupil_mask, self.map_axis,
self.mm, self.mmc, self.md)
self.count += 1
# print("\n", "Running: Covariance Slice", self.method, 'with roi_envelope = ',self.roi_envelope,'; roi_belowGround = ',self.roi_belowGround)
if self.print_fitting == True:
print("Iteration:", self.count)
print("Target Array:", self.target_array)
print("Method:", self.method)
print("Layer Altitudes:", self.layer_alt)
print("L0:", L0)
print("Track:", track)
print("r0:", r0)
print("Shift: {}".format(shwfs_shift))
print("Rotation: {}".format(shwfs_rot))
self.r0 = r0.astype('float')
self.L0 = L0.astype('float')
self.track = track.astype('float')
self.shwfs_rot = shwfs_rot.astype('float')
self.shwfs_shift = shwfs_shift.astype('float')
return covariance