def correctcouple(a, dispy, couple_input, cut=0.01, app=0, path="./"):
sm = couple_input.sensitivity_matrix
if np.count_nonzero(sm) < 1:
raise ValueError('Sensitivity matrix has only zeros')
R = np.transpose(sm)
vector=couple_input.computevector(a,dispy)
wg=couple_input.wg
weisvec = np.array(np.concatenate([
np.sqrt(wg[0])*np.ones(len(couple_input.couplelist)),
np.sqrt(wg[1])*np.ones(len(couple_input.couplelist)),
np.sqrt(wg[2])*np.ones(len(couple_input.couplelist)),
np.sqrt(wg[3])*np.ones(len(couple_input.couplelist)),
np.sqrt(wg[4])*np.ones(len(couple_input.dispylist))
])
)
Rnew = np.transpose(np.transpose(R)*weisvec)
delta = -matrixmultiply(generalized_inverse(Rnew,cut), (vector-couple_input.zerovector)/couple_input.normvector)
write_params(delta, couple_input.varslist, app, path=path)
return [delta, couple_input.varslist]
def bCorrNumeric(X, Y, DX, beat_input, cut=0.001, app=0, path="./"):
R = np.transpose(beat_input.sensitivity_matrix)
b = beat_input.computevectorEXP(X, Y, DX) - beat_input.zerovector
corr = beat_input.varslist
m, n = np.shape(R)
if len(b) == m and len(corr) == n:
rms, ptop = calcRMSNumeric(b)
inva = generalized_inverse(R, cut)
print "initial {RMS, Peak}: { %e , %e } mm" % (rms, ptop)
print "finding best over", n, "correctors"
for i in range(n):
dStren = matrixmultiply(inva[i, :], b)
bvec = b - matrixmultiply(R[:, i], dStren)
rm, ptp = calcRMSNumeric(bvec)
if rm < rms:
rms = rm
rbest = i
rStren = dStren
if ptp < ptop:
ptop = ptp
pbest = i
pStren = dStren
print "final {RMS, Peak}: { %e , %e }" % (rms, ptop)
if rbest == pbest:
print "best corr:", corr[rbest], '%e' % (rStren), "1/m"
else:
print "--- warning: best corr for rms & peak are not same"
print "RMS best corr:", corr[rbest], '%e' % (rStren), "1/m"
print "Peak best corr:", corr[pbest], '%e' % (pStren), "1/m"
else:
print "dimensional mismatch in input variables"
def bCorrNumeric(X, Y, DX, beat_input, cut=0.001, app=0, path="./"):
R = np.transpose(beat_input.sensitivity_matrix)
b = beat_input.computevectorEXP(X, Y, DX) - beat_input.zerovector
corr = beat_input.varslist
m, n = np.shape(R)
if len(b) == m and len(corr) == n:
rms, ptop = calcRMSNumeric(b)
inva = generalized_inverse(R, cut)
print "initial {RMS, Peak}: { %e , %e } mm" % (rms, ptop)
print "finding best over", n, "correctors"
for i in range(n):
dStren = matrixmultiply(inva[i, :], b)
bvec = b - matrixmultiply(R[:, i], dStren)
rm, ptp = calcRMSNumeric(bvec)
if rm < rms:
rms = rm
rbest = i
rStren = dStren
if ptp < ptop:
ptop = ptp
pbest = i
pStren = dStren
print "final {RMS, Peak}: { %e , %e }" % (rms, ptop)
if rbest == pbest:
print "best corr:", corr[rbest], '%e' % (rStren), "1/m"
else:
print "--- warning: best corr for rms & peak are not same"
print "RMS best corr:", corr[rbest], '%e' % (rStren), "1/m"
print "Peak best corr:", corr[pbest], '%e' % (pStren), "1/m"
else:
print "dimensional mismatch in input variables"
def correctcouple(a, dispy, couple_input, cut=0.01, app=0, path="./"):
sm = couple_input.sensitivity_matrix
if np.count_nonzero(sm) < 1:
raise ValueError('Sensitivity matrix has only zeros')
R = np.transpose(sm)
vector = couple_input.computevector(a, dispy)
wg = couple_input.wg
weisvec = np.array(
np.concatenate([
np.sqrt(wg[0]) * np.ones(len(couple_input.couplelist)),
np.sqrt(wg[1]) * np.ones(len(couple_input.couplelist)),
np.sqrt(wg[2]) * np.ones(len(couple_input.couplelist)),
np.sqrt(wg[3]) * np.ones(len(couple_input.couplelist)),
np.sqrt(wg[4]) * np.ones(len(couple_input.dispylist))
]))
Rnew = np.transpose(np.transpose(R) * weisvec)
delta = -matrixmultiply(
generalized_inverse(Rnew, cut),
(vector - couple_input.zerovector) / couple_input.normvector)
write_params(delta, couple_input.varslist, app, path=path)
return [delta, couple_input.varslist]
def itrSVD(X,
Y,
DX,
beat_input,
cut=0.001,
num_iter=1,
app=0,
tol=1e-9,
path="./"):
R = np.transpose(beat_input.sensitivity_matrix)
b = beat_input.computevectorEXP(X, Y, DX) - beat_input.zerovector
corr = beat_input.varslist
inva = generalized_inverse(R, cut)
rmss, ptopp = calcRMSNumeric(b)
RHO2 = {}
dStren = np.zeros(len(corr))
print 'Initial Phase-Beat:', '{RMS,PK2PK}', rmss, ptopp
for ITER in range(num_iter): # @UnusedVariable
dStren = dStren + matrixmultiply(inva, b)
bvec = b - matrixmultiply(R, dStren)
rm, ptp = calcRMSNumeric(bvec)
print 'ITER', num_iter, '{RMS,PK2PK}', rm, ptp
for j in range(len(corr)):
RHO2[corr[j]] = dStren[j]
wrtpar(corr, RHO2, app, path)
def correctbeatEXP(x,
y,
dx,
beat_input,
cut=0.01,
app=0,
path="./",
xbet=[],
ybet=[]):
R = np.transpose(beat_input.sensitivity_matrix)
vector = beat_input.computevectorEXP(x, y, dx, xbet, ybet)
wg = beat_input.wg
weisvec = np.array(
np.concatenate([
np.sqrt(wg[0]) * np.ones(len(beat_input.phasexlist)),
np.sqrt(wg[1]) * np.ones(len(beat_input.phaseylist)),
np.sqrt(wg[2]) * np.ones(len(beat_input.betaxlist)),
np.sqrt(wg[3]) * np.ones(len(beat_input.betaylist)),
np.sqrt(wg[4]) * np.ones(len(beat_input.displist)),
np.sqrt(wg[5]) * np.ones(2)
]))
Rnew = np.transpose(np.transpose(R) * weisvec)
delta = -matrixmultiply(generalized_inverse(
Rnew, cut), (vector - beat_input.zerovector) / beat_input.normvector)
writeparams(delta, beat_input.varslist, app, path)
return [delta, beat_input.varslist]
def correctbeatEXP2(x,
x2,
y,
y2,
dx,
dx2,
beat_input2,
cut=0.01,
app=0,
path="./"):
###########################################################
R = transpose(beat_input2.sensitivity_matrix)
vector = beat_input2.computevectorEXP2(x, x2, y, y2, dx, dx2)
wg = beat_input2.wg
weisvec = array(
concatenate([
sqrt(wg[0]) *
ones(len(beat_input2.phasexlist) + len(beat_input2.phasexlist2)),
sqrt(wg[1]) *
ones(len(beat_input2.phaseylist) + len(beat_input2.phaseylist2)),
sqrt(wg[2]) *
ones(len(beat_input2.betaxlist) + len(beat_input2.betaxlist2)),
sqrt(wg[3]) *
ones(len(beat_input2.betaylist) + len(beat_input2.betaylist2)),
sqrt(wg[4]) *
ones(len(beat_input2.displist) + len(beat_input2.displist2)),
sqrt(wg[5]) * ones(4)
]))
Rnew = transpose(transpose(R) * weisvec)
#print (vector-beat_input.zerovector) # Good line to debug big correction strs
delta = -matrixmultiply(generalized_inverse(
Rnew, cut), (vector - beat_input2.zerovector) / beat_input2.normvector)
writeparams(delta, beat_input2.varslist, app, path)
return [delta, beat_input2.varslist]
def correctcouple2(couple,
couple2,
dispy,
dispy2,
couple_input2,
cut=0.01,
app=0,
path="./"):
################################################
R = transpose(couple_input.sensitivity_matrix2)
vector = couple_input2.computevector2(couple, couple2, dispy, dispy2)
wg = couple_input2.wg
weisvec = array(
concatenate([
sqrt(wg[0]) * ones(len(couple_input2.couplelist)),
sqrt(wg[0]) * ones(len(couple_input2.couplelist2)),
sqrt(wg[1]) * ones(len(couple_input2.couplelist)),
sqrt(wg[1]) * ones(len(couple_input2.couplelist2)),
sqrt(wg[2]) * ones(len(couple_input2.couplelist)),
sqrt(wg[2]) * ones(len(couple_input2.couplelist2)),
sqrt(wg[3]) * ones(len(couple_input2.couplelist)),
sqrt(wg[3]) * ones(len(couple_input2.couplelist2)),
sqrt(wg[4]) * ones(len(couple_input2.dispylist)),
sqrt(wg[4]) * ones(len(couple_input2.dispylist2))
]))
Rnew = transpose(transpose(R) * weisvec)
delta = -matrixmultiply(
generalized_inverse(Rnew, cut),
(vector - couple_input2.zerovector) / couple_input2.normvector)
writeparams(delta, couple_input2.varslist, app, path=path)
return [delta, couple_input2.varslist]
def correctcouple(a, dispy, couple_input, cut=0.01, app=0, path="./"): ################################################ print "one" R= transpose(couple_input.sensitivity_matrix) vector=couple_input.computevector(a,dispy) wg=couple_input.wg print len(couple_input.couplelist), wg[2] weisvec=array(concatenate([sqrt(wg[0])*ones(len(couple_input.couplelist)),sqrt(wg[1])*ones(len(couple_input.couplelist)),sqrt(wg[2])*ones(len(couple_input.couplelist)),sqrt(wg[3])*ones(len(couple_input.couplelist)),sqrt(wg[4])*ones(len(couple_input.dispylist))])) Rnew=transpose(transpose(R)*weisvec) delta=-matrixmultiply(generalized_inverse(Rnew,cut),(vector-couple_input.zerovector)/couple_input.normvector) writeparams(delta, couple_input.varslist, app, path=path) return [delta, couple_input.varslist]
def correctcouple(a, dispy, couple_input, cut=0.01, app=0, path="./"): ################################################ print "one" R= transpose(couple_input.sensitivity_matrix) vector=couple_input.computevector(a,dispy) wg=couple_input.wg print len(couple_input.couplelist), wg[2] weisvec=array(concatenate([sqrt(wg[0])*ones(len(couple_input.couplelist)),sqrt(wg[1])*ones(len(couple_input.couplelist)),sqrt(wg[2])*ones(len(couple_input.couplelist)),sqrt(wg[3])*ones(len(couple_input.couplelist)),sqrt(wg[4])*ones(len(couple_input.dispylist))])) Rnew=transpose(transpose(R)*weisvec) delta=-matrixmultiply(generalized_inverse(Rnew,cut),(vector-couple_input.zerovector)/couple_input.normvector) writeparams(delta, couple_input.varslist, app, path=path) return [delta, couple_input.varslist]
def bNCorrNumeric(X,
Y,
DX,
beat_input,
cut=0.001,
ncorr=3,
app=0,
tol=1e-9,
path="./",
beta_x=None,
beta_y=None):
R = np.transpose(beat_input.sensitivity_matrix)
n = np.shape(R)[1]
b = beat_input.computevectorEXP(X, Y, DX, beta_x,
beta_y) - beat_input.zerovector
corr = beat_input.varslist
inva = generalized_inverse(R, cut)
RHO2 = {}
rmss, ptopp = calcRMSNumeric(b)
print 'Initial Phase-beat {RMS,PK2PK}:', rmss, ptopp
for ITER in range(ncorr):
for j in range(n):
if j not in RHO2:
RHO = [k for k in RHO2.keys()]
RHO.append(j)
RR = np.take(R, RHO, 1)
invaa = np.take(inva, RHO, 0)
dStren = matrixmultiply(invaa, b)
#--- calculate residual due to 1..nth corrector
bvec = b - matrixmultiply(RR, dStren)
rm, ptp = calcRMSNumeric(bvec)
if rm < rmss:
rmss = rm
ptopp = ptp
rbest = j
rStren = dStren
print 'ITER:', ITER + 1, ' RMS,PK2PK:', rmss, ptopp
RHO2[rbest] = (rmss, ptopp)
if (rm < tol):
print "RMS converged with", ITER, "correctors"
break
if (rm < rmss):
print "stopped after", ITER, "correctors"
break
itr = 0
RHO3 = {} #-- make dict RHO3={corr:strength,...}
for j in RHO2:
RHO3[corr[j]] = rStren[itr]
itr += 1
print '\n', sortDict(RHO3)
wrtpar(corr, RHO3, app, path)
return RHO3
def correctbeat(a, beat_input, cut=0.01, app=0, path="./"):
R = np.transpose(beat_input.sensitivity_matrix)
vector = beat_input.computevector(a)
wg = beat_input.wg
weisvec = np.array(np.concatenate([np.sqrt(wg[0])*np.ones(len(beat_input.phasexlist)),
np.sqrt(wg[1])*np.ones(len(beat_input.phaseylist)),
np.sqrt(wg[2])*np.ones(len(beat_input.betaxlist)),
np.sqrt(wg[3])*np.ones(len(beat_input.betaylist)),
np.sqrt(wg[4])*np.ones(len(beat_input.displist)),
np.sqrt(wg[5])*np.ones(2)]))
Rnew = np.transpose(np.transpose(R)*weisvec)
delta = -matrixmultiply( generalized_inverse(Rnew, cut), (vector-beat_input.zerovector)/beat_input.normvector )
writeparams(delta, beat_input.varslist, app, path=path)
def correctbeat(a,beat_input, cut=0.01, app=0, path="./"):
################################################
R= transpose(beat_input.sensitivity_matrix)
vector=beat_input.computevector(a)
wg=beat_input.wg
weisvec=array(concatenate([sqrt(wg[0])*ones(len(beat_input.phasexlist)),
sqrt(wg[1])*ones(len(beat_input.phaseylist)),
sqrt(wg[2])*ones(len(beat_input.betaxlist)),
sqrt(wg[3])*ones(len(beat_input.betaylist)),
sqrt(wg[4])*ones(len(beat_input.displist)),
sqrt(wg[5])*ones(2)]))
Rnew=transpose(transpose(R)*weisvec)
delta=-matrixmultiply(generalized_inverse(Rnew,cut),(vector-beat_input.zerovector)/beat_input.normvector)
writeparams(delta, beat_input.varslist, app, path=path)
return
def correctbeatEXP2(x,x2,y,y2,dx,dx2,beat_input2, cut=0.01, app=0, path="./"):
###########################################################
R= transpose(beat_input2.sensitivity_matrix)
vector=beat_input2.computevectorEXP2(x,x2,y,y2,dx,dx2)
wg=beat_input2.wg
weisvec=array(concatenate([sqrt(wg[0])*ones(len(beat_input2.phasexlist)+len(beat_input2.phasexlist2)),
sqrt(wg[1])*ones(len(beat_input2.phaseylist)+len(beat_input2.phaseylist2)),
sqrt(wg[2])*ones(len(beat_input2.betaxlist)+len(beat_input2.betaxlist2)),
sqrt(wg[3])*ones(len(beat_input2.betaylist)+len(beat_input2.betaylist2)),
sqrt(wg[4])*ones(len(beat_input2.displist)+len(beat_input2.displist2)),
sqrt(wg[5])*ones(4)]))
Rnew=transpose(transpose(R)*weisvec)
#print (vector-beat_input.zerovector) # Good line to debug big correction strs
delta=-matrixmultiply(generalized_inverse(Rnew,cut),(vector-beat_input2.zerovector)/beat_input2.normvector)
writeparams(delta, beat_input2.varslist, app, path)
return [delta, beat_input2.varslist]
def itrSVD(X, Y, DX, beat_input, cut=0.001, num_iter=1, app=0, tol=1e-9, path="./"):
R = np.transpose(beat_input.sensitivity_matrix)
b = beat_input.computevectorEXP(X, Y, DX) - beat_input.zerovector
corr = beat_input.varslist
inva = generalized_inverse(R, cut)
rmss, ptopp = calcRMSNumeric(b)
RHO2 = {}
dStren = np.zeros(len(corr))
print 'Initial Phase-Beat:', '{RMS,PK2PK}', rmss, ptopp
for ITER in range(num_iter): # @UnusedVariable
dStren = dStren + matrixmultiply(inva, b)
bvec = b - matrixmultiply(R, dStren)
rm, ptp = calcRMSNumeric(bvec)
print 'ITER', num_iter, '{RMS,PK2PK}', rm, ptp
for j in range(len(corr)):
RHO2[corr[j]] = dStren[j]
wrtpar(corr, RHO2, app, path)
def correctcouple2(couple, couple2, dispy, dispy2, couple_input2, cut=0.01, app=0, path="./"): ################################################ R=transpose(couple_input.sensitivity_matrix2) vector=couple_input2.computevector2(couple, couple2, dispy, dispy2) wg=couple_input2.wg weisvec=array(concatenate([sqrt(wg[0])*ones(len(couple_input2.couplelist)), sqrt(wg[0])*ones(len(couple_input2.couplelist2)), sqrt(wg[1])*ones(len(couple_input2.couplelist)), sqrt(wg[1])*ones(len(couple_input2.couplelist2)), sqrt(wg[2])*ones(len(couple_input2.couplelist)), sqrt(wg[2])*ones(len(couple_input2.couplelist2)), sqrt(wg[3])*ones(len(couple_input2.couplelist)), sqrt(wg[3])*ones(len(couple_input2.couplelist2)), sqrt(wg[4])*ones(len(couple_input2.dispylist)), sqrt(wg[4])*ones(len(couple_input2.dispylist2))])) Rnew=transpose(transpose(R)*weisvec) delta=-matrixmultiply(generalized_inverse(Rnew,cut),(vector-couple_input2.zerovector)/couple_input2.normvector) writeparams(delta, couple_input2.varslist, app, path=path) return [delta, couple_input2.varslist]
def correctbeatEXP(x, y, dx, beat_input, cut=0.01, app=0, path="./", xbet=[], ybet=[]):
R = np.transpose(beat_input.sensitivity_matrix)
vector = beat_input.computevectorEXP(x, y, dx, xbet, ybet)
errwg = beat_input.errwg
if errwg == 1:
weisvec = beat_input.computeweightvectorEXP(x, y, dx, xbet, ybet)
else:
wg = beat_input.wg
weisvec = np.array(np.concatenate([wg[0]*np.ones(len(beat_input.phasexlist)),
wg[1]*np.ones(len(beat_input.phaseylist)),
wg[2]*np.ones(len(beat_input.betaxlist)),
wg[3]*np.ones(len(beat_input.betaylist)),
wg[4]*np.ones(len(beat_input.displist)),
wg[5]*np.ones(2)]))
Rnew = np.transpose(np.transpose(R)*weisvec)
delta = -matrixmultiply(generalized_inverse(Rnew, cut), (vector-beat_input.zerovector)*weisvec/beat_input.normvector)
writeparams(delta, beat_input.varslist, beat_input.accel_path, app, path)
return [delta, beat_input.varslist]
def bNCorrNumeric(X, Y, DX, beat_input, cut=0.001, ncorr=3, app=0, tol=1e-9, path="./", beta_x=None, beta_y=None):
R = np.transpose(beat_input.sensitivity_matrix)
n = np.shape(R)[1]
b = beat_input.computevectorEXP(X, Y, DX, beta_x, beta_y) - beat_input.zerovector
corr = beat_input.varslist
inva = generalized_inverse(R, cut)
RHO2 = {}
rmss, ptopp = calcRMSNumeric(b)
print 'Initial Phase-beat {RMS,PK2PK}:', rmss, ptopp
for ITER in range(ncorr):
for j in range(n):
if j not in RHO2:
RHO = [k for k in RHO2.keys()]
RHO.append(j)
RR = np.take(R, RHO, 1)
invaa = np.take(inva, RHO, 0)
dStren = matrixmultiply(invaa, b)
#--- calculate residual due to 1..nth corrector
bvec = b - matrixmultiply(RR, dStren)
rm, ptp = calcRMSNumeric(bvec)
if rm < rmss:
rmss = rm
ptopp = ptp
rbest = j
rStren = dStren
print 'ITER:', ITER+1, ' RMS,PK2PK:', rmss, ptopp
RHO2[rbest] = (rmss, ptopp)
if (rm < tol):
print "RMS converged with", ITER, "correctors"
break
if (rm < rmss):
print "stopped after", ITER, "correctors"
break
itr = 0
RHO3 = {} #-- make dict RHO3={corr:strength,...}
for j in RHO2:
RHO3[corr[j]] = rStren[itr]
itr += 1
print '\n', sortDict(RHO3)
wrtpar(corr, RHO3, app, path)
return RHO3
def correctcouple(a, chromcouple_input, cut=0.01, app=0, path="./"):
R = np.transpose(chromcouple_input.sensitivity_matrix)
vector = chromcouple_input.compute_vector(a)
wg = chromcouple_input.wg
len_couplelist = len(chromcouple_input.couplelist)
weisvec = np.array(np.concatenate(
[np.sqrt(wg[0])*np.ones(len_couplelist),
np.sqrt(wg[1])*np.ones(len_couplelist),
np.sqrt(wg[2])*np.ones(len_couplelist),
np.sqrt(wg[3])*np.ones(len_couplelist)]
)
)
Rnew = np.transpose(np.transpose(R)*weisvec)
delta = -matrixmultiply(generalized_inverse(Rnew,cut), (vector-chromcouple_input.zerovector)/chromcouple_input.normvector)
write_params(delta, chromcouple_input.varslist, app, path=path)
return [delta, chromcouple_input.varslist]
def __init__(self, parent, config, args={}, forGUISetup=0, debug=None):
if type(parent) != type({}):
parent = {"cent": parent}
aobase.aobase.__init__(self, parent, config)
self.dataValid = 1 #data is valid even before first iter as assume mirror starts zerod.
self.nMirrorModes = self.config.getVal("nMirrorModes")
if forGUISetup == 1:
self.outputData = [(self.nMirrorModes, ), na.float64]
else:
self.nsubx = self.config.getVal("wfs_nsubx")
n = self.wfs_n = self.config.getVal("wfs_n")
self.outputData = na.zeros((self.nMirrorModes, ), na.float64)
self.dmType = self.config.getVal("dmType", default="zernike")
self.pupil = self.config.getVal("pupil")
self.subarea = self.pupil.subarea #na.zeros((self.nsubx,self.nsubx),na.float64)
self.subflag = self.pupil.subflag #na.zeros((self.nsubx,self.nsubx),na.int8)
self.pupsub = self.pupil.pupsub #na.zeros((self.nsubx,self.nsubx,self.wfs_n,self.wfs_n),na.float64)
self.dmpupil = self.pupil.dmpupil #na.zeros(self.pupil.fn.shape,na.int32)
if self.subflag.itemsize == 8:
print "WARNING: untested with 8 byte longs...(wfs)"
wfs_minarea = self.config.getVal(
"wfs_minarea"
) #0.5... # Min unvignetted subap area to use - why here ????
## for i in range(self.nsubx):
## for j in range(self.nsubx):
## self.pupsub[i][j]=self.pupil.fn[i*n:(i+1)*n,j*n:(j+1)*n].astype(na.float64) # Get pupil fn over subaps
## self.subarea[i][j]=na.sum(na.sum(self.pupsub[i][j]))
## if(self.subarea[i][j]>(wfs_minarea*n*n)):
## self.subflag[i][j]=1# Flag vignetted subaps
## self.dmpupil[i*n:(i+1)*n,j*n:(j+1)*n]=self.pupil.fn[i*n:(i+1)*n,j*n:(j+1)*n].astype(na.int32)
#get the number of atmospheric layers to be used in reconstruction. For a single WFS case, this is just one (no 3d profiling).
self.nReconLayers = self.config.getVal("nReconLayers")
self.wfsn = self.config.getVal("wfs_n")
self.nsubaps = self.nsubx * self.nsubx
self.r0 = self.config.getVal("r0")
self.npup = self.config.getVal("npup")
self.telDiam = self.config.getVal("telDiam")
if self.dmType == "zernike":
import zernikeDM
self.dm = zernikeDM.dm(self.pupil,
self.nMirrorModes) #create a DM object
else:
print "DM type %s not known - assuming zernike" % self.dmType
self.dm = zernikeDM.dm(self.pupil, self.nMirrorModes)
#get the mirror mode area - for a continuous mirror, this will be the whole mirror, while for a segmented mirror, it will be the area of a segment.
self.mirrorModeArea = self.dm.computeModeArea()
self.turbProfileType = self.config.getVal("turbProfileType",
default="kolmogorov")
#get the turb profile information. This is a dictionary, with keys being the order of differentiation - only 1 and 2 are used here.
#The values are then dictionaries of what is the differentiating variable, ie x or y.
#The values of these are then arrays of the function.
self.turbProfile = []
if self.turbProfileType == "kolmogorov": #actually, create one of these per layer (or 1 if using single wfs).
for i in range(
self.nReconLayers
): #actually, do something here to apply a different r0 for each layer...
self.turbProfile.append(
self.kolmogorovProfile(
self.r0 / self.telDiam * self.npup, self.npup * 4))
else:
self.turbProfile = self.turbProfileType #assume type stores the actual profile.
self.wfsSearchPath = self.config.getVal(
"wfsSearchPath"
) #this will be something like [["wfscent","globals"],...] depending on the wfs module used. It is used to create a dummy wfs to compute noise statistics, and so should allow the values for a given wfs to be obtained. When using more than one wfs, they should be appended in the list, eg [["wfscent_1","wfscent","globals"],["wfscent_2",...]]
# compute the G^-1 part.
print "computing dm inv geom cov matrix" #shape=(nmode-1,nmode-1) - piston removed
self.invGeomCovarianceMatrix = self.dm.computeInvGeomCovarianceMatrix(
)
#compute the noise covariance matrix - shape=(ncent,)
print "computing noise covariances"
self.noiseCovarianceMatrix = self.computeNoiseCovariance()
#compute the slope covariance matrix - shape=(ncent,ncent)
print "computing slope covariance matrix"
self.slopeCovarianceMatrix = self.computeSlopeCovarianceMatrix()
#add noise to slope
print "adding noise and slope covariances"
for i in range(self.nsubaps * 2):
self.slopeCovarianceMatrix[i,
i] += self.noiseCovarianceMatrix[i]
if self.noiseCovarianceMatrix[i] == na.NaN:
print "mapRecon - noiseCovarianceMatrix has NaN at %d" % i
#compute the invrse of the noise and slope covariance matrix
#print na.array(self.slopeCovarianceMatrix)
#print na.sum(na.sum(self.slopeCovarianceMatrix-na.transpose(self.slopeCovarianceMatrix)))
print "inverting covariance matrix" #shape=(ncent,ncent)
try:
self.invNoiseSlopeMatrix = LA.cho_solve(
LA.cho_factor(self.slopeCovarianceMatrix),
na.identity(self.slopeCovarianceMatrix.shape[0]))
except:
print "noiseSlopeCovarianceMatrix may not be positive definite - trying generatlised inverse"
self.invNoiseSlopeMatrix = NALA.generalized_inverse(
self.slopeCovarianceMatrix)
#compute the slope/dm covariance matrix - shape=(nmode-1,ncent)
print "computing slope/dm cov mat"
self.slopeDMCovMatrix = self.computeSlopeDMCovarianceFunction()
#multiply together to get reconstructor
print "multiplying to create reconstructor"
#print self.slopeDMCovMatrix.shape,self.invNoiseSlopeMatrix.shape
#print na.sum(na.sum(self.slopeDMCovMatrix)),na.sum(na.sum(self.invNoiseSlopeMatrix))
tmpProd = quick.dot(
self.slopeDMCovMatrix,
self.invNoiseSlopeMatrix) #shape=(nmode-1,ncent)
#print self.invGeomCovarianceMatrix.shape,tmpProd.shape
#print na.sum(na.sum(self.invGeomCovarianceMatrix)),na.sum(na.sum(tmpProd))
self.reconstructor = quick.dot(self.invGeomCovarianceMatrix,
tmpProd) #shape=(nmode-1,ncent)
self.inputData = na.zeros((self.nsubaps * 2, ), na.float64)
self.centx = self.inputData[:self.nsubaps]
self.centy = self.inputData[self.nsubaps:]
