def subap_layer_positions_atSeparations(self):
"""Calculates the position of every sub-aperture pairing (within the covariance map ROI) in the telescope's pupil.
The number of sub-aperture pairings at each covariance map ROI data point is also calculated so that mean
covariance can be found."""
covMapDim = (self.pupil_mask.shape[0] * 2) - 1
onesMat = numpy.ones(
(int(self.pupil_mask.sum()), int(self.pupil_mask.sum())))
wfs_subap_pos = (numpy.array(numpy.where(self.pupil_mask == 1)).T *
self.tel_diam / self.pupil_mask.shape[0])
onesMM, onesMMc, mapDensity = get_mappingMatrix(
self.pupil_mask, onesMat)
xPosMM, xMMc, d = get_mappingMatrix(self.pupil_mask,
onesMat * wfs_subap_pos.T[0])
yPosMM, yMMc, d = get_mappingMatrix(self.pupil_mask,
onesMat * wfs_subap_pos.T[1])
xPosMM[onesMM == 0] = numpy.nan
yPosMM[onesMM == 0] = numpy.nan
ySeps = numpy.ones(
(self.combs, self.roi_width, self.roi_length, self.nx_subap**
2)) * numpy.nan
xSeps = numpy.ones(
(self.combs, self.roi_width, self.roi_length, self.nx_subap**
2)) * numpy.nan
self.meanDenominator = numpy.zeros(self.cov_xx[..., 0].shape)
self.subap_sep_positions = numpy.ones(
(self.combs, self.roi_width, self.roi_length, self.nx_subap**2, 2))
self.allMapPos[self.allMapPos >= covMapDim] = 0.
for comb in range(self.combs):
mmLocations = (covMapDim * self.allMapPos[comb, :, :, 0]
) + self.allMapPos[comb, :, :, 1]
self.meanDenominator[comb] = onesMM[:, mmLocations].sum(0)
ySepsMM = -yPosMM[:, mmLocations]
xSepsMM = -xPosMM[:, mmLocations]
for env in range(self.roi_width):
for l in range(self.roi_length):
ySeps[comb, env, l] = ySepsMM[:, env, l]
xSeps[comb, env, l] = xSepsMM[:, env, l]
self.subap_sep_positions[comb, :, :, :, 0] = xSeps[comb]
self.subap_sep_positions[comb, :, :, :, 1] = ySeps[comb]
# stop
# self.meanDenominator[0] = mapDensity
self.meanDenominator[self.meanDenominator == 0] = 1.
self.meanDenominator = numpy.stack([self.meanDenominator] *
self.n_layer, 3)
# subap_diam = numpy.array([0.205]*n_wfs)
# n_subap = numpy.array([1248]*n_wfs)
# nx_subap = numpy.array([40]*n_wfs)
# """HARMONI"""
# tel_diam = 39.0
# obs_diam = 4.0
# subap_diam = numpy.array([0.507]*n_wfs)
# n_subap = numpy.array([4260]*n_wfs)
# nx_subap = numpy.array([74]*n_wfs)
pupil_mask = make_pupil_mask('circle', n_subap, nx_subap[0], obs_diam,
tel_diam)
matrix_region_ones = numpy.ones((n_subap[0], n_subap[0]))
mm, mmc, md = get_mappingMatrix(pupil_mask, matrix_region_ones)
onesMat, wfsMat_1, wfsMat_2, allMapPos, selector, xy_separations = roi_referenceArrays(
pupil_mask, gs_pos, tel_diam, roi_belowGround, roi_envelope)
params = covariance_roi(pupil_mask,
subap_diam,
wavelength,
tel_diam,
n_subap,
gs_alt,
gs_pos,
n_layer,
layer_alt,
L0,
allMapPos,
return cov_map
if __name__ == '__main__':
"""Test CANARY"""
# n_wfs = 2
# nx_subap = numpy.array([7, 7])
# n_subap = numpy.array([36, 36])
# tel_diam = 4.2
# obs_diam = 1.0
# roi_axis = 'x+y'
# pupil_mask = make_pupil_mask('circle', numpy.array([n_subap[0]]), nx_subap[0], obs_diam, tel_diam)
# mm, mmc, md = get_mappingMatrix(pupil_mask, numpy.ones((n_subap[0], n_subap[0])))
# cov_matrix = numpy.ones((n_wfs * n_subap[0] * 2, n_wfs * n_subap[0] * 2))
# cov_map = covMap_fromMatrix(cov_matrix, n_wfs, nx_subap, n_subap, pupil_mask, roi_axis, mm, mmc, md)
"""Test AOF"""
n_wfs = 1
nx_subap = numpy.array([40, 40])
n_subap = numpy.array([1240, 1240])
tel_diam = 8.2
obs_diam = 1.1
roi_axis = 'x+y'
pupil_mask = make_pupil_mask('circle', numpy.array([n_subap[0]]), nx_subap[0], obs_diam, tel_diam)
mm, mmc, md = get_mappingMatrix(pupil_mask, numpy.ones((n_subap[0], n_subap[0])))
cov_matrix = numpy.ones((n_wfs * n_subap[0] * 2, n_wfs * n_subap[0] * 2))
cov_map = covMap_fromMatrix(cov_matrix, n_wfs, nx_subap, n_subap, pupil_mask, roi_axis, mm, mmc, md)
def __init__(self,
pupil_mask,
subap_diam,
wavelength,
tel_diam,
n_subap,
gs_alt,
gs_pos,
n_layer,
layer_alt,
r0,
L0,
styc_method=True,
wind_profiling=False,
tt_track_present=False,
lgs_track_present=False,
offset_present=False,
fit_layer_alt=False,
fit_tt_track=False,
fit_lgs_track=False,
fit_offset=False,
fit_L0=False,
matrix_xy=True,
huge_matrix=False,
l3s1_transform=False,
l3s1_matrix=None,
remove_tt=False,
remove_tt_matrix=None):
"""Configuration used to generate covariance matrix.
Parameters:
pupil_mask (ndarray): mask of SHWFS sub-apertures within the telescope's pupil.
subap_diam (ndarray): diameter of SHWFS sub-aperture in telescope's pupil.
wavelength (ndarray): SHWFS centroid wavelengh (nm).
tel_diam (float): diameter of telescope pupil.
n_subap (ndarray): number of sub-apertures within each SHWFS.
gs_alt (ndarray): GS altitude. 0 for NGS (LGS not tested!).
gs_pos (ndarray): GS asterism in telescope FoV.
n_layer (int): number of turbulent layers.
layer_alt (ndarray): altitudes of turbulent layers (m).
wind_profiling (bool): determines whether covariance map ROI is to be used for wind profiling.
tt_track_present (bool): generate covariance map ROI with linear additions to covariance (from vibrations/track).
offset_present (bool): determines whether covariance map ROI is to account for a SHWFS shift/rotation.
fit_tt_track (bool): determines whether the generated covariance matrix is to fit track.
fit_offset (bool): determines whether the generated covariance matrix is to fit SHWFS shift/rotation.
fit_L0 (bool): determines whether generated covariance map ROI is to be used for L0 profiling.
r0 (ndarray): r0 profile (m).
L0 (ndarray): L0 profile (m).
styc_method (bool): use styc method of analytically generating covariance.
matrix_xy (bool): generate orthogonal covariance e.g. x1y1.
huge_matrix (bool): if array size n_layer * cov_matrix is too big, reduce to cov_matrix (takes longer to generate)."""
self.n_wfs = gs_pos.shape[0]
self.subap_diam = subap_diam
self.wavelength = wavelength
self.tel_diam = tel_diam
self.pupil_mask = pupil_mask
self.n_subap_from_pupilMask = int(self.pupil_mask.sum())
self.gs_alt = gs_alt
# Swap X and Y GS positions to agree with legacy code
self.gs_pos = gs_pos[:, ::-1]
self.n_layer = n_layer
self.layer_alt = layer_alt
self.combs = int(comb(gs_pos.shape[0], 2, exact=True))
selector = numpy.array((range(self.n_wfs)))
self.selector = numpy.array((list(itertools.combinations(selector,
2))))
self.n_subap = n_subap
self.total_subaps = int(numpy.sum(self.pupil_mask) * self.n_wfs)
self.styc_method = styc_method
self.radSqaured_to_arcsecSqaured = ((180. / numpy.pi) * 3600)**2
self.fit_L0 = fit_L0
self.translation = numpy.zeros((self.n_layer, self.n_wfs, 2))
self.subap_layer_diameters = numpy.zeros(
(self.n_layer, self.n_wfs)).astype("float64")
self.wind_profiling = wind_profiling
self.offset_present = offset_present
self.fit_layer_alt = fit_layer_alt
self.fit_offset = fit_offset
self.offset_set = False
self.matrix_xy = matrix_xy
self.scale_factor = numpy.zeros((n_layer, self.n_wfs))
self.tt_track_set = False
self.fit_tt_track = fit_tt_track
self.tt_track_present = tt_track_present
if self.fit_tt_track == True or self.tt_track_present == True:
self.tt_trackMatrix_locs = tt_trackMatrix_locs(
2 * self.n_subap_from_pupilMask * self.n_wfs,
self.n_subap_from_pupilMask)
self.tt_track = numpy.zeros(
(self.tt_trackMatrix_locs.shape)).astype('float64')
self.lgs_track_set = False
self.fit_lgs_track = fit_lgs_track
self.lgs_track_present = lgs_track_present
if self.fit_lgs_track == True or self.lgs_track_present == True:
self.lgs_trackMatrix_locs = matrix_lgs_trackMatrix_locs(
2 * self.n_subap_from_pupilMask * self.n_wfs, self.n_subap,
self.n_subap_from_pupilMask)
self.lgs_track = numpy.zeros(
(self.lgs_trackMatrix_locs.shape)).astype('float64')
#make l3s1 transform matrix
self.l3s1_transform = l3s1_transform
if l3s1_transform == True:
if l3s1_matrix is None:
self.l3s1_matrix = transform_matrix(
numpy.array([self.n_subap_from_pupilMask] * self.n_wfs),
self.n_wfs)
else:
self.l3s1_matrix = l3s1_matrix
#make matrix for removing tip-tilt
self.remove_tt = remove_tt
if remove_tt == True:
if remove_tt_matrix is None:
self.remove_tt_matrix = tt_removal_matrix(
self.n_subap_from_pupilMask, self.n_wfs)
else:
self.remove_tt_matrix = remove_tt_matrix
#parameters required for fast generation of aligned/auto covariance
mat_roi = numpy.ones(
(int(self.pupil_mask.sum()), int(self.pupil_mask.sum())))
self.mm, mmc, md = get_mappingMatrix(self.pupil_mask, mat_roi)
mapOnes = covMap_superFast((pupil_mask.shape[0] * 2) - 1, mat_roi,
self.mm, mmc, md)
self.flatMM = mapOnes.flatten().astype('int')
self.fill_xx = numpy.zeros(self.flatMM.shape)
self.fill_yy = numpy.zeros(self.flatMM.shape)
self.fill_xy = numpy.zeros(self.flatMM.shape)
loc_mapOnes = numpy.where(mapOnes == 1)
covMapDim = (self.pupil_mask.shape[0] * 2) - 1
xMapSep = numpy.ones((covMapDim, covMapDim)) * numpy.arange(
-(pupil_mask.shape[0] - 1),
(pupil_mask.shape[0])) * self.tel_diam / pupil_mask.shape[0]
xMapSepFlat = xMapSep.flatten()
yMapSep = xMapSep.copy().T
yMapSepFlat = yMapSep.flatten()
yloc_mapOnes = xMapSep[loc_mapOnes[0], loc_mapOnes[1]]
xloc_mapOnes = yMapSep[loc_mapOnes[0], loc_mapOnes[1]]
if self.offset_present == False and self.fit_offset == False:
self.subap_positions = [False] * self.n_wfs
self.xy_separations = numpy.array((xloc_mapOnes, yloc_mapOnes)).T
if self.offset_present == True or self.fit_offset == True:
self.subap_positions_wfsAlignment = numpy.zeros(
(self.n_wfs, self.n_subap_from_pupilMask, 2)).astype("float64")
wfs_subap_pos = (numpy.array(numpy.where(self.pupil_mask == 1)).T *
self.tel_diam / self.pupil_mask.shape[0])
self.subap_positions = numpy.array([wfs_subap_pos] * self.n_wfs)
self.auto_xy_separations = numpy.array(
(xloc_mapOnes, yloc_mapOnes)).T
if huge_matrix == True:
print('\n' + 'THIS MATRIX BE HUUUUGGGEEEE')
self.huge_matrix = True
else:
self.huge_matrix = False
# Compile covariance matrix
if self.huge_matrix == False:
self.covariance_matrix = numpy.zeros(
(self.n_layer, 2 * self.total_subaps,
2 * self.total_subaps)).astype("float64")
else:
self.cov_mat = numpy.zeros(
(2 * self.total_subaps,
2 * self.total_subaps)).astype("float64")
self.covariance_matrix = numpy.zeros(
(2 * self.total_subaps,
2 * self.total_subaps)).astype("float64")
if self.fit_layer_alt == False:
#calculate fixed parameters
self.subap_parameters()
self.timingStart = time.time()
if self.fit_L0 == self.offset_present == self.fit_offset == self.wind_profiling == self.huge_matrix == False:
self.compile_matrix(r0, L0)
def roi_referenceArrays(pupil_mask, gs_pos, tel_diam, belowGround, envelope):
"""Collection of arrays used to simplify covariance map ROI processing.
Parameters:
pupil_mask (ndarray): mask of sub-aperture positions within telescope pupil.
gs_pos (ndarray): GS positions.
tel_diam (float): telescope diameter.
belowGround (int): number of sub-aperture separations the ROI expresses 'below-ground'.
envelope (int): number of sub-aperture separations the ROI expresses either side of stellar separation.
Returns:
mm (ndarray): Mapping Matrix.
sa_mm (ndarray): Mapping Matrix sub-aperture numbering of SHWFS 1.
sb_mm (ndarray): Mapping Matrix sub-aperture numbering of SHWFS 2.
allMapPos (ndarray): ROI coordinates in each covariance map combination.
selector (ndarray): array of all covariance map combinations.
xy_separations (ndarray): x and y sub-aperture separations corresponding to allMapPos."""
#Collect mapping matrix (mm), x/y sub-aperture mapping matrix
nxSubaps = pupil_mask.shape[0]
subapDiam = tel_diam / nxSubaps
nSubaps = numpy.int(numpy.sum(pupil_mask))
covMapDim = (nxSubaps * 2) - 1
blankCovMap = numpy.zeros((covMapDim, covMapDim))
posMatrix = numpy.ones((nSubaps, nSubaps))
#mm - mapping matrix, mmc - mapping matrix coordinates, md - map denominator
# mm, mmc, md = get_mappingMatrix(numpy.fliplr(pupil_mask), posMatrix)
# mm, mmc, md = get_mappingMatrix(numpy.fliplr(pupil_mask), posMatrix)
mm, mmc, md = get_mappingMatrix(pupil_mask, posMatrix)
mm = mm.astype(int)
onesMap = covMap_superFast(covMapDim, posMatrix, mm, mmc, md)
nanMap = onesMap.copy()
nanMap[nanMap == 0] = numpy.nan
#sa_mm - mm sub-aperture numbering of shwfs1, sb_mm - mm sub-aperture numbering of shwfs2
sa_mm, mmc, md = get_mappingMatrix(pupil_mask,
posMatrix * numpy.arange(nSubaps)[::-1])
sb_mm, mmc, md = get_mappingMatrix(
pupil_mask, numpy.rot90(posMatrix * numpy.arange(nSubaps)[::-1], 3))
# sb_mm, mmc, md = get_mappingMatrix(pupil_mask, posMatrix*numpy.arange(nSubaps))
# sa_mm, mmc, md = get_mappingMatrix(pupil_mask, numpy.rot90(posMatrix*numpy.arange(nSubaps),3))
sa_mm = sa_mm.astype(int)
sb_mm = sb_mm.astype(int)
#Determine no. of GS combinations
combs = int(comb(gs_pos.shape[0], 2, exact=True))
selector = numpy.array((range(gs_pos.shape[0])))
selector = numpy.array((list(itertools.combinations(selector, 2))))
# fakePosMap, b, t = gamma_vector(blankCovMap, 1, 'False', belowGround, envelope, False)
# print('No. of GS combinations:', combs, '\n')
#Sub-aperture postions for generateSliceCovariance and map vectors for mapSliceFromSlopes
sliceWidth = 1 + (2 * envelope)
sliceLength = pupil_mask.shape[0] + belowGround
subapNum = numpy.ones((2, combs, sliceWidth, sliceLength))
subapLocations = numpy.zeros((2, combs, sliceWidth, sliceLength, 2))
subapLocations1 = numpy.zeros((combs, sliceWidth, sliceLength, 2))
subapLocations2 = numpy.zeros((combs, sliceWidth, sliceLength, 2))
allMapPos = numpy.zeros((combs, sliceWidth, sliceLength, 2)).astype(int)
vectorMap = numpy.zeros(
(combs * blankCovMap.shape[0], blankCovMap.shape[1]))
refArray = arrayRef(pupil_mask)
#x and y separations in covariance map space - used to get xy_separations
yMapSep_square = numpy.ones(nanMap.shape) * numpy.arange(
-(pupil_mask.shape[0] - 1),
(pupil_mask.shape[0])) * tel_diam / pupil_mask.shape[0]
# yMapSep = nanMap.copy() * numpy.arange(-(pupil_mask.shape[0]-1), (pupil_mask.shape[0])) * tel_diam/pupil_mask.shape[0]
yMapSep = nanMap.copy() * yMapSep_square
xMapSep = nanMap.copy() * yMapSep_square.T
xy_separations = numpy.zeros((combs, sliceWidth, sliceLength, 2))
# stop
for k in range(combs):
posMap = 0.
posMap, vector, t = gamma_vector(blankCovMap, 'False',
gs_pos[selector[k]], belowGround,
envelope,
False) #gets covariance map vector
# posMap[:,:,0] = numpy.flipud(posMap[:,:,0])
# posMap[:,:,1] = numpy.flipud(posMap[:,:,1])
# vector = numpy.rot90(vector,1)
xy_separations[k] = numpy.stack(
(xMapSep[posMap.T[0], posMap.T[1]], yMapSep[posMap.T[0],
posMap.T[1]])).T
#Make all vector coordinates off-map 2*covMapDiam
for i in range(posMap.shape[0]):
for j in range(posMap.shape[1]):
if onesMap[posMap[i, j, 0], posMap[i, j, 1]] == 0:
posMap[i, j] = 2 * covMapDim, 2 * covMapDim
#Sub-aperture positions for specific GS combination. All non-positions are nan
subapPos1 = numpy.ones(posMap.shape) * numpy.nan
subapPos2 = numpy.ones(posMap.shape) * numpy.nan
for i in range(posMap.shape[0]):
subapPos = []
for j in range(posMap.shape[1]):
if posMap[i, j, 0] != 2 * covMapDim:
pupil_mask1 = numpy.zeros(pupil_mask.shape)
pupil_mask2 = numpy.zeros(pupil_mask.shape)
#Sub-aperture numbers that correspond to the required covariance measurements. Uses mapping matrix as look-up table.
subapNum1 = sa_mm[:, posMap[i, j, 0] * covMapDim +
(posMap[i, j, 1])][numpy.where(
mm[:, posMap[i, j, 0] * covMapDim +
(posMap[i, j, 1])] == 1)[0]][0]
subapNum2 = sb_mm[:, posMap[i, j, 0] * covMapDim +
(posMap[i, j, 1])][numpy.where(
mm[:, posMap[i, j, 0] * covMapDim +
(posMap[i, j, 1])] == 1)[0]][0]
# print subapNum1, '\n'
subapNum[0, k, i, j] = subapNum1
subapNum[1, k, i, j] = subapNum2
#Converts first set of sub-aperture to their displacement from the centre of the telescope's pupil.
pupil_mask1[numpy.where(refArray == subapNum1)] = 1
subapPos1[i, j] = numpy.asarray(
numpy.where(pupil_mask1 == 1)).T * subapDiam
# subapPos1[i,j] -= tel_diam/2.
# subapPos1[i,j] += subapDiam/2.
#Converts second set of sub-aperture to their displacement from the centre of the telescope's pupil.
pupil_mask2[numpy.where(refArray == subapNum2)] = 1
subapPos2[i, j] = numpy.asarray(
numpy.where(pupil_mask2 == 1)).T * subapDiam
# subapPos2[i,j] -= tel_diam/2.
# subapPos2[i,j] += subapDiam/2.
subapLocations1[k] = subapPos1
subapLocations2[k] = subapPos2
allMapPos[k] = posMap
vectorMap[k * blankCovMap.shape[0]:(k + 1) *
blankCovMap.shape[0]] = vector
#subapPositons is a list of shape (2, combs, 1+2*envelope, vectorLength (i.e. 7/8 for CANARY), 2)
subapLocations[0] = subapLocations1
subapLocations[1] = subapLocations2
# subapLocations.append(subapLocations1)
# subapLocations.append(subapLocations2)
subapPos.append(subapPos1[0])
subapPos.append(subapPos2[0])
# stop
# print('\n'+'################ REFERENCE ARRAYS OBTAINED ###############', '\n')
return mm, sa_mm, sb_mm, allMapPos, selector, xy_separations
def __init__(self, turb_results, wind_config_file):
"""Fixes variables from config_file that are to be used to complete turbulence profiling.
Parameters:
config_file (dict): fitting specifications set in imported yaml configuration file."""
self.turb_results = turb_results
self.tel_diam = self.turb_results.tel_diam
self.n_wfs = self.turb_results.n_wfs
self.n_subap = self.turb_results.n_subap
self.n_subap_from_pupilMask = turb_results.n_subap_from_pupilMask
self.nx_subap = self.turb_results.nx_subap
self.pupil_mask = self.turb_results.pupil_mask
self.shwfs_centroids = self.turb_results.shwfs_centroids
self.gs_pos = self.turb_results.gs_pos
self.n_layer = self.turb_results.n_layer
self.observable_bins = self.turb_results.observable_bins
self.offset_present = self.turb_results.offset_present
self.cn2_noiseFloor = self.turb_results.cn2_noiseFloor
self.L0 = self.turb_results.L0
self.tt_track = self.turb_results.tt_track
self.lgs_track = self.turb_results.lgs_track
self.combs = self.turb_results.combs
self.selector = self.turb_results.selector
self.shwfs_shift = self.turb_results.shwfs_shift
self.shwfs_rot = self.turb_results.shwfs_rot
target_conf = wind_config_file.configDict["OFFSET TARGET ARRAY"]
self.input_shwfs_centroids = target_conf["input_shwfs_centroids"]
self.roi_via_matrix = target_conf["roi_via_matrix"]
self.reduce_SL = target_conf["reduce_SL"]
self.zeroSep_cov = target_conf["zeroSep_cov"]
self.input_frame_count = target_conf["input_frame_count"]
self.num_offsets = target_conf["num_offsets"]
self.offset_step = target_conf["offset_step"]
self.temporal_step = numpy.round(
float(self.offset_step) / float(self.num_offsets)).astype('int')
self.include_temp0 = target_conf["include_temp0"]
self.minus_negativeTemp = target_conf["minus_negativeTemp"]
self.separate_pos_neg_offsets = target_conf["separate_pos_neg_offsets"]
self.wind_roi_belowGround = target_conf["roi_belowGround"]
self.wind_roi_envelope = target_conf["roi_envelope"]
self.wind_map_axis = target_conf["map_axis"]
self.wind_mapping_type = target_conf["mapping_type"]
fit_params = wind_config_file.configDict["FITTING ALGORITHM"]
self.delta_xSep = numpy.array(
fit_params["delta_xSep"]).astype('float64')
self.delta_ySep = numpy.array(
fit_params["delta_ySep"]).astype('float64')
if len(self.delta_xSep) != self.n_layer:
raise Exception('Check length of wind parameters with n_layer.')
if self.reduce_SL == True:
if self.n_wfs != 4:
raise Exception(
'To reduce the data there must be 4 GSs in a square asterism.'
)
if self.offset_present == True:
raise Exception(
'When reducing square layout optical alignment must be assumed.'
)
fit_conf = wind_config_file.configDict["FITTING ALGORITHM"]
self.fitting_type = fit_conf["type"]
self.fit_layer_alt = fit_conf["fit_layer_alt"]
self.fit_deltaXYseps = fit_conf["fit_deltaXYseps"]
self.print_fiting = fit_conf["print_fitting"]
self.onesMat, self.wfsMat_1, self.wfsMat_2, self.allMapPos, self.selector, self.xy_separations = roi_referenceArrays(
self.pupil_mask, self.gs_pos, self.tel_diam,
self.wind_roi_belowGround, self.wind_roi_envelope)
if self.reduce_SL == True:
# stop
self.selector = numpy.array(([[0, 1], [0, 2], [0, 3], [1, 2],
[1, 3], [3, 2]]))
if self.zeroSep_cov == False:
roi_width = (2 * self.wind_roi_envelope) + 1
roi_length = self.pupil_mask.shape[0] + self.wind_roi_belowGround
self.zeroSep_locations = roi_zeroSep_locations(
self.combs, roi_width, roi_length, self.wind_map_axis,
self.wind_roi_belowGround)
else:
self.zeroSep_locations = numpy.nan
if self.minus_negativeTemp == True:
self.mult_neg_offset = -1.
else:
self.mult_neg_offset = 1.
if wind_config_file.configDict["FITTING ALGORITHM"][
"type"] == 'direct':
self.fit_method = 'Direct Fit'
self.direct_wind = True
self.l3s_wind = False
self.l3s1_matrix = numpy.nan
if wind_config_file.configDict["FITTING ALGORITHM"]["type"] == 'l3s':
self.fit_method = 'L3S Fit'
self.l3s_wind = True
self.direct_wind = False
if self.turb_results.l3s_fit == True:
self.l3s1_matrix = self.turb_results.l3s1_matrix
else:
self.l3s1_matrix = transform_matrix(
self.n_subap_from_pupilMask, self.n_wfs)
if self.turb_results.covariance_map == True or self.turb_results.covariance_map_roi == True:
self.mm = self.turb_results.mm
self.mmc = self.turb_results.mmc
self.md = self.turb_results.md
else:
matrix_region_ones = numpy.ones((self.n_subap_from_pupilMask[0],
self.n_subap_from_pupilMask[0]))
self.mm, self.mmc, self.md = get_mappingMatrix(
self.pupil_mask, matrix_region_ones)
print('\n' +
'############ WIND PROFILING PARAMETERS SECURE #############')