def _plot(self):
import gist
gist.window(self.id, wait=1)
gist.animate(1)
gist.pltitle(self.title)
gist.palette(self.palette)
gist.gridxy(self.grid)
if self.limits != None:
gist.limits(self._getLimit('xmin'), self._getLimit('xmax'),
self._getLimit('ymin'), self._getLimit('ymax'))
def _plot(self):
import gist
gist.window(self.id, wait = 1)
gist.animate(1)
gist.pltitle(self.title)
gist.palette(self.palette)
gist.gridxy(self.grid)
if self.limits != None:
gist.limits(self._getLimit('xmin'),
self._getLimit('xmax'),
self._getLimit('ymin'),
self._getLimit('ymax'))
def change_palette(pal):
if pal is not None:
if isinstance(pal, types.StringType):
try:
gist.palette('%s.gp' % pal)
except gist.error:
if len(pal) > 3 and pal[-2:] == 'gp':
gist.palette(pal)
else:
raise ValueError, "Palette %s not found." % pal
else:
data = Numeric.transpose(Numeric.asarray(pal))
data = data.astype('B')
gist.palette(*transpose(data))
def change_palette(pal):
if pal is not None:
if isinstance(pal, types.StringType):
try:
gist.palette('%s.gp' % pal)
except gist.error:
if len(pal) > 3 and pal[-2:] == 'gp':
gist.palette(pal)
else:
raise ValueError, "Palette %s not found." % pal
else:
data = numpy.transpose(numpy.asarray(pal))
data = data.astype (numpy.uint8)
gist.palette(*transpose(data))
def handle(self, data):
"""Handle data returned from the simulation"""
if data[1] == "warning" or data[1] == "error":
print "Error retrieving data", data[1:], data[0]
elif len(self.gettype()) == 0: #not doing anything with it...
pass
else:
if self.when[:3] != "rpt" or self.repeating == 1: #still expecting data
if self.ret != None and data[3].has_key(self.ret):
data = data[3][self.ret]
else:
data = None
ret = self.ret
if ret == None:
ret = "None"
if self.button == None:
d = {ret: data, "button": None}
else:
d = {ret: data, "button": self.button[0]}
try:
exec self.preprocess in d
except:
pass
if self.button != None:
self.button[0] = d["button"]
data = d[ret]
dim = self.dim
xaxis = self.xaxis
if dim == None:
if type(data) == numpy.ndarray:
if len(data.shape) > 1:
dim = 2
elif len(data.shape) == 1:
dim = 1
else:
dim = 0
else:
dim = 0
if dim == 1:
if type(self.xaxis) == types.NoneType:
if len(data.shape) > 1:
xaxis = data[0]
data = data[1:]
else:
xaxis = numpy.arange(data.shape[0])
data = data
else:
if type(self.xaxis) == types.StringType:
xaxis = eval(self.xaxis)
if self.gisttype:
if type(data) == numpy.ndarray:
if not self.info.has_key("window"):
self.info["window"] = 0
if not self.info.has_key("palette"):
self.info["palette"] = "gray.gp"
if not self.info.has_key("gistdpi"):
self.info["gistdpi"] = 75
if self.gistWindow == None:
self.gistWindow = gist.window(
self.info["window"],
wait=1,
dpi=self.info["gistdpi"])
gist.animate(0)
gist.animate(1)
gist.palette(self.info["palette"])
else:
gist.window(self.gistWindow)
#gist.fma()
if dim == 1:
for i in range(data.shape[0]):
gist.plg(data[i], xaxis)
else:
gist.pli(data)
gist.fma()
else:
print "Cannot display type %s with gist" % str(
type(data))
if self.pylabtype:
if type(data) == numpy.ndarray:
if not self.info.has_key("palette"):
self.info["palette"] = "gray"
if not self.info.has_key("interp"):
self.info["interp"] = "nearest"
if not self.info.has_key("plotwin"):
self.info["plotwin"] = mypylab.plot()
p = self.info["plotwin"]
p.win.set_title(self.title)
p.newPalette(self.info["palette"])
p.newInterpolation(self.info["interp"])
p.deactivatefn = self.cancel #deactivate
p = self.info["plotwin"]
if dim == 1:
p.dims = 1
axis = xaxis
else:
p.dims = 2
axis = None
if p.active:
p.plot(data, axis=axis)
else:
if self.button != None:
self.button[0] = 0
#print "Not expecting this data any more... (simdata.handle, type=pylab)"
self.repeating = 0
else:
print "Cannot display type %s with pylab" % str(
type(data))
if self.texttype:
#self.info["texttype"]=="ownwindow, mainwindow", default own
#self.info["replace"]==1 or 0, default 0
if not self.info.has_key("wintype"):
self.info["wintype"] = "ownwindow"
if not self.info.has_key("textreplace"):
self.info["textreplace"] = 0
if self.info["wintype"] == "ownwindow":
if self.textWindow == None:
self.textWindow = textbox(self.title)
self.textWindow.closeFunc = self.cancel #deactivate
if self.textWindow.destroyed == 0:
#print "adding text",str(data)
self.textWindow.addText(
str(data) + "\n",
replace=self.info["textreplace"])
else: #tell simulation not to send...
print "Not expecting this data any more... (simdata.handle, type=text)"
self.textWindow = None
self.repeating = 0
else:
print str(data)
if self.savetype:
if not self.info.has_key("filetype"):
self.info["filetype"] = "fits"
if not self.info.has_key("filename"):
self.info["filename"] = "tmp.fits"
if not self.info.has_key("filereplace"):
self.info["filereplace"] = 0
if self.info["filetype"] == "fits":
if type(data) == numpy.ndarray:
print "WARNING - depreciated - use util.FITS instead (code needs updating)"
if self.info["filereplace"]:
imghdu = util.pyfits.PrimaryHDU(
numarray.array(data))
imghdu.header.update("DATE", time.asctime())
imghdu.header.update("USER",
os.environ["USER"])
imghdu.header.update(
"CREATOR", "simctrl.py simulation control")
imghdu.header.update("TITLE", str(self.title))
imghdu.header.update("COMMAND", str(self.cmd))
imghdu.header.update("RETURN", str(self.ret))
imghdu.header.update("TYPE", self.gettype())
imghdu.header.update("PREPROC",
str(self.preprocess))
imghdu.header.update("DIMS", str(self.dim))
imghdu.header.update("XAXIS", str(self.xaxis))
imghdu.header.update("WHEN", str(self.when))
imghdu.header.update("INFO", str(self.info))
hdulist = util.pyfits.HDUList([imghdu])
hdulist.writeto(self.info["filename"],
clobber=True)
else:
f = util.pyfits.open(self.info["filename"],
mode="update")
imghdu = util.pyfits.ImageHDU(
numarray.array(data))
imghdu.header.update("DATE", time.asctime())
imghdu.header.update("USER",
os.environ["USER"])
imghdu.header.update(
"CREATOR", "simctrl.py simulation control")
imghdu.header.update("TITLE", str(self.title))
imghdu.header.update("COMMAND", str(self.cmd))
imghdu.header.update("RETURN", str(self.ret))
imghdu.header.update("TYPE", self.gettype())
imghdu.header.update("PREPROC",
str(self.preprocess))
imghdu.header.update("DIMS", str(self.dim))
imghdu.header.update("XAXIS", str(self.xaxis))
imghdu.header.update("WHEN", str(self.when))
imghdu.header.update("INFO", str(self.info))
f.append(imghdu)
f.close()
else:
print "Cannot save fits data of this format:", type(
data)
elif self.info["filetype"] == "csv":
if self.info["filereplace"]:
mode = "w"
else:
mode = "a"
f = open(self.info["filename"], mode)
f.write(
"#Date\t%s\n#User\t%s\n#Creator\tsimctrl.py simulation control\n#Title\t%s\n#Command\t%s\n#Return\t%s\n#Type\t%s\n#Preprocess\t%s\n#Dims\t%s\n#Xaxis\t%s\n#When\t%s\n#Info\t%s\n"
% (time.asctime(), os.environ["USER"],
str(self.title), str(self.cmd), str(self.ret),
self.gettype(), str(self.preprocess),
str(self.dim), str(self.xaxis), str(
self.when), str(self.info)))
if dim == 1:
try:
for i in range(xaxis.shape[0]):
f.write("%g" % float(xaxis[i]))
for j in range(data.shape[0]):
f.write("\t%g" % float(data[j][i]))
f.write("\n")
f.write("\n")
except:
print "Data not in correct 1D format - can't save as csv"
f.write(str(data))
f.write("\n\n")
else:
print "Can't save 2D data as csv... using text instead"
f.write(str(data))
f.write("\n\n")
f.close()
elif self.info["filetype"] == "text":
if self.info["filereplace"]:
mode = "w"
else:
mode = "a"
f = open(self.info["filename"], mode)
f.write(
"#Date\t%s\n#User\t%s\n#Creator\tsimctrl.py simulation control\n#Title\t%s\n#Command\t%s\n#Return\t%s\n#Type\t%s\n#Preprocess\t%s\n#Dims\t%s\n#Xaxis\t%s\n#When\t%s\n#Info\t%s\n"
% (time.asctime(), os.environ["USER"],
str(self.title), str(self.cmd), str(self.ret),
self.gettype(), str(self.preprocess),
str(self.dim), str(self.xaxis), str(
self.when), str(self.info)))
f.write(str(data))
f.write("\n\n")
f.close()
else:
print "Unrecognised filetype - not saving"
if self.feedbacktype:
try:
d = {"feedback": data}
exec self.info["feedbackmsg"] in d
msg = d["msg"]
except:
msg = "Feedback data:" + str(data)
print msg
exec self.post
else:
print "Warning: No longer expecting data for", self.cmd
def doit(zernlist=None,
nact=9,
cents=None,
avphase=None,
readnoise=10.,
usePoisson=1,
sig=1000.,
fullpupil=0,
monteNoiseCovariance=0,
phaseCov="bccb",
diagonaliseinvChatReordered=1,
diagonaliseA=0.5,
useChatFromDiagonalisedA=1,
oversampleFFT=0,
fft2d=1,
oversampleAndBinFFTofr=0,
removeHiFreqZ=0,
removeHiFreqP=0,
removeHiFreqX=0,
convToPxl=1):
"""Create a zernike mode and get the centroids for this. Put these centroids into the PCG algorithm, and recreate the phase, and then compare with the original input phase
defaultOptions are:
diagonaliseinvChatReordered:1#should we diagonlise C-1, or use whole MX?
diagonaliseA:0#should we diagonalise A or use the whole MX.
useChatFromDiagonalisedA:1#should we compute invChat using a diagonalised chat or not?
zernlist can be a dict of zernikes eg {3:1} would be focus, amplitude 1...
or it can be the phase, or it can be none (in which case a phasescreen is
created).
This now seems to be working fairly well, iterates to an exact solution after about 10 iters, and 4-5 should be sufficient for a good solution.
"""
options = {
"diagonaliseinvChatReordered": diagonaliseinvChatReordered,
"diagonaliseA": diagonaliseA,
"useChatFromDiagonalisedA": useChatFromDiagonalisedA,
"oversampleFFT": oversampleFFT,
"2dfft": fft2d,
"oversampleAndBinFFTofr": oversampleAndBinFFTofr,
"removeHiFreqZ": removeHiFreqZ,
"removeHiFreqP": removeHiFreqP,
"removeHiFreqX": removeHiFreqX
}
gist.window(0)
gist.palette("gray.gp")
pupfn = util.tel.Pupil(nact - 1, (nact - 1) / 2., 0).fn
actfn = util.tel.Pupil(nact, nact / 2., 0).fn
noiseCov = None
if type(cents) == type(None):
if type(zernlist) in [type(1), type(1.)]:
zernlist = {zernlist: 1.}
elif type(zernlist) == type([]):
tmp = {}
for i in zernlist:
tmp[i] = 1.
zernlist = tmp
elif type(zernlist) == type(None):
zernlist = science.infScrn.makeInitialScreen(dpix=(nact - 1) * 8,
Dtel=4.2,
L0=30.,
scrnXPxls=None,
scrnYPxls=None,
seed=None,
tstep=0.05,
globR0=0.2,
strLayer=1.,
natype=numpy.float64,
windDirection=0.,
vWind=10.)[:-1,
1:].copy()
c, phase, avphase = getFocusCents(zernlist,
nact=nact,
readnoise=readnoise,
usePoisson=usePoisson,
sig=sig,
plot=1,
fullpupil=fullpupil)
print phase.shape
cents = c.cent
if monteNoiseCovariance:
noiseCov = c.computeNoiseCovariance(20, convertToRad=1)
if convToPxl: #convert from radians to pixel values for the noises...
radToPxlFactor = 1. / c.convFactor**2
else:
radToPxlFactor = 1.
Pcg = testfull(fromdisk=0,
nact=nact,
pupfn=pupfn,
actfn=actfn,
fullpmx=1,
noiseCov=noiseCov,
phaseCov=phaseCov,
options=options,
radToPxlFactor=radToPxlFactor) #agbhome
Pcg.newCentroids(cents)
Pcg.initialise()
#now inverse A, multiply with b, to get the MVM reconstructed phase...
invA = numpy.linalg.inv(Pcg.A)
gist.fma()
gist.pli(invA)
raw_input("Displaying inverse of A... press return")
gist.fma()
gist.pli(phase)
raw_input("The phase... press a key")
recphase = quick.dot(invA, Pcg.b)
print "Reconstructed phase min/max:", min(recphase.flat), max(
recphase.flat)
recphase.shape = (9, 9)
gist.window(4)
gist.palette("gray.gp")
gist.fma()
gist.pli(recphase)
gist.palette("gray.gp")
gist.window(0)
chires = numpy.zeros((100, ), "d")
#also compute what a traditional MVM with pokemx would give...
#invpokemx=numpy.linalg.pinv(Pcg.pokemx)#same as generalised_inverse
#pmphase=quick.dot(invpokemx,cents)
print "Press return for next iteration or key+return to quit"
#gist.fma()
#gist.pli(numpy.reshape(pmphase,(nact,nact)))
if type(avphase) != type(None):
print "press a key"
raw_input()
gist.fma()
gist.pli(avphase)
actphase = phase2acts(avphase)
actphase -= numpy.average(actphase.flat) #remove piston
smallpupfn = util.tel.Pupil(nact, nact / 2. - 2, 0).fn
raw_input("press return (min, max actphase is %g %g" %
(min(actphase.flat), max(actphase.flat)))
gist.fma()
gist.pli(actphase)
gist.window(1)
gist.palette("gray.gp")
gist.window(2)
gist.palette("gray.gp")
niter = 0
while len(raw_input()) == 0:
niter += 1
gist.window(1)
gist.fma()
img = numpy.reshape(Pcg.x.real, (nact, nact))
gist.pli(img)
gist.window(2)
gist.fma()
img = smallpupfn * img
#gist.pli(numpy.where(img==0,min(img.flat),img))
gist.pli(numpy.reshape(Pcg.p, (nact, nact)))
gist.window(3)
gist.fma()
fftimg = numpy.fft.fft2(numpy.reshape(Pcg.x, (nact, nact)))
gist.pli(fftimg.real)
Pcg.nextIter()
chirespos = niter - 1
if chirespos > 99:
chirespos = 99
chires[chirespos] = chi2(Pcg.x, recphase,
scale=0) #changed from actphase
Pcg.alphaHist[chirespos] = Pcg.alpha
Pcg.betaHist[chirespos] = Pcg.beta
Pcg.tolerance[chirespos] = max(numpy.fabs(Pcg.xprev - Pcg.x))
print niter, Pcg.tolerance[chirespos], chires[chirespos], min(
Pcg.x.real), max(Pcg.x.real), min(Pcg.p), max(
Pcg.p), Pcg.alphaHist[chirespos], Pcg.betaHist[chirespos]
print "Press return for next iteration or key+return to quit"
gist.fma()
gist.plg(chires[:chirespos])
gist.window(2)
gist.fma()
gist.plg(Pcg.tolerance[:niter])
gist.window(0)
return Pcg, actphase, phase, recphase, c