def __init__(self, PSF_Interpolator=PSF_Interpolator(),
PSF_Evaluator=Moment_Evaluator(), model=None,
**kwargs):
"""
Parameters
----------
PSF_Interpolator : PSF_Interpolator object
This is the object that gives you PSF properties at a given
location on the focal plane.
PSF_Evaluator : PSF_Evaluator object
This is the object that evaluates stamps and gives you psf
properties.
model : dataframe
This is the data of a wavefront. So then this becomes the thing
against which we compare.
"""
self.PSF_Interpolator = PSF_Interpolator
self.PSF_Evaluator = PSF_Evaluator
self.PSF_Evaluator_keys = self.PSF_Evaluator.keys
# this is useful
self.decaminfo = decaminfo()
if model is not None:
self.data = model
self.field, self.bins_x, self.bins_y = self.reduce_data_to_field(self.data, **kwargs)
def generate_one_coordinate_per_bin(num_bins, decaminfo=decaminfo()):
x = []
y = []
if num_bins >= 2:
num_bins_make = num_bins + (num_bins-1)
else:
num_bins_make = num_bins
for key in decaminfo.infoDict.keys():
if 'F' in key:
continue
xi, yi = decaminfo.getBounds(key, num_bins_make)
xi = np.array(xi)
xi = 0.5 * (xi[1:] + xi[:-1])
yi = np.array(yi)
yi = 0.5 * (yi[1:] + yi[:-1])
xi, yi = np.meshgrid(xi, yi)
xi = xi.flatten()
yi = yi.flatten()
x += list(xi)
y += list(yi)
x = np.array(x)
y = np.array(y)
return x, y
from ROOT import TGraph2D,TCanvas,TH2F
from decamutil import decaminfo
import ROOT
from ROOT import gStyle
import numpy as np
decam = decaminfo()
ns = np.genfromtxt('/mnt/hgfs/VMShared/output/DES_analysis/results.txt', delimiter='\t',dtype = 'str', skiprows=1, usecols = [7], unpack = True)#, dtype, comments, delimiter, converters, skiprows, usecols, unpack, ndmin)
ns_num, sigma, grad = np.genfromtxt('/mnt/hgfs/VMShared/output/DES_analysis/results.txt', delimiter='\t', skiprows=1, usecols = [8,12,14], unpack = True)#, dtype, comments, delimiter, converters, skiprows, usecols, unpack, ndmin)
names = []
for i, name in enumerate(ns):
names.append(name + str(int(ns_num[i])))
del ns
grad*= 100
c1 = TCanvas( 'canvas', 'canvas', 1200, 1200)
graph = TGraph2D()
# dummy = TH2F('hist','hist',100,-186,186,100,-192,192)
# #dummy.SetPoint(0,-185.9805,-191.6625, 3.8)
# #dummy.SetPoint(1, 185.9955, 191.6775, 4.5)
# #dummy.SetPoint(2, 185.9955, 191.6775, 100)
# #dummy.SetPoint(3, 185.9955, 191.6775, -100)
# for i in range(10):
# dummy.Fill(0,0,1)
# #dummy.GetZaxis().SetRangeUser(3.8,4.2)
#
def digest_fits(self, file_name, columns=None,
exclude=['VIGNET', 'FLUX_APER', 'FLUXERR_APER',
'MAG_APER', 'MAGERR_APER'],
ext=2, do_exclude=False, **kwargs):
try:
#from astropy.table import Table
from astropy.io import fits
except Exception:
print('No Astropy installation. Trying pyfits!')
try:
import pyfits as fits
except Exception:
raise ImportError('Astropy and Pyfits both missing!')
hdu = fits.open(file_name)
data = hdu[ext].data
df = DataFrame.from_records(data, exclude=exclude, columns=columns)
if 'MAG_APER' in exclude:
for i in xrange(data['MAG_APER'].shape[1]):
df['MAG_APER_{0}'.format(i)] = data['MAG_APER'][:, i]
if 'x' not in df.keys() and 'XWIN_IMAGE' in df.keys() and 'ext' in df.keys():
decaminf = decaminfo()
# get focal plane coordinates
xPos = df['XWIN_IMAGE']
yPos = df['YWIN_IMAGE']
extnums = df['ext'].values
x, y = decaminf.getPosition_extnum(extnums, xPos, yPos)
df['x'] = x
df['y'] = y
# TODO: This is a really annoying hackaround the endianness problem:
# turn everything into floats. This should be fixed in the next major
# astropy release 1.1
df = df.astype('<f8')
# estimate the errors
# TODO: need to take in the header in ext1
# and parse sky background levels
if len(hdu) == 3 and ext == 2:
# look at ext 1 to get background values
sexhead = hdu[1].data[0][0]
# now we need to get the sky value from the header
sky = 0
for string in sexhead:
if 'SEXBKDEV' in string:
sky = float(string.split('/')[0].split('=')[1])
break
# okay now we need to compute diagonal variances
e0 = df['e0']
e1 = df['e1']
e2 = df['e2']
delta1 = df['delta1']
delta2 = df['delta2']
zeta1 = df['zeta1']
zeta2 = df['zeta2']
flux = df['FLUX_ADAPTIVE']
# compute
variances = estimate_ellipticity_and_octupole_variance(e0, e1, e2,
delta1, delta2, zeta1, zeta2,
flux, sky)
# assign
var_e0, var_e1, var_e2, var_zeta1, var_zeta2, \
var_delta1, var_delta2 = variances
df['var_e0'] = var_e0
df['var_e1'] = var_e1
df['var_e2'] = var_e2
df['var_zeta1'] = var_zeta1
df['var_zeta2'] = var_zeta2
df['var_delta1'] = var_delta1
df['var_delta2'] = var_delta2
# also add std for convenience
df['std_e0'] = sqrt(var_e0)
df['std_e1'] = sqrt(var_e1)
df['std_e2'] = sqrt(var_e2)
df['std_zeta1'] = sqrt(var_zeta1)
df['std_zeta2'] = sqrt(var_zeta2)
df['std_delta1'] = sqrt(var_delta1)
df['std_delta2'] = sqrt(var_delta2)
if do_exclude:
# return the df and the excluded
return df, data#[exclude]
else:
return df
def generate_random_coordinates(number, decaminfo=decaminfo()):
x = np.random.random(number) * 2048
y = np.random.random(number) * 4096
extnum = np.random.randint(1, 63, number)
x, y = decaminfo.getPosition_extnum(extnum, x, y)
return x, y, extnum
def __init__(self, **inputDict):
# default values for calibration information
# see doit.txt file 10/14/2012
# comes from 20120914seq1 suplmented by 20121001seq1 for tilts
# I've rounded to 2 sig. figures, removed elements to correct for 15deg rotation,
# symmetrized, then added the LR sub-matrix to match Zemax,
# then finally inverted and rounded.
#
# hexapodM =
# matrix ([[ 0.0e+00, -2.6e+05, 4.5e+03, 0.0e+00],
# [ -2.6e+05, -0.0e+00, -0.0e+00, -4.5e+03],
# [ -5.3e+04, -0.0e+00, -0.0e+00, -9.8e+01],
# [ 0.0e+00, 5.3e+04, -9.8e+01, 0.0e+00]])
hexapodArrayDiagonal = numpy.array(
(
(0.0e00, -2.6e05, 4.5e03, 0.0e00),
(-2.6e05, 0.0e00, 0.0e00, -4.5e03),
(-5.3e04, 0.0e00, 0.0e00, -9.8e01),
(0.0e00, 5.3e04, -9.8e01, 0.0e00),
)
)
# now replace this with the array from the actual measurements, which
# still includes the 15deg hexapod rotation
hexapodArrayRotated = numpy.array(
(
(-1.9e5, -1.6e5, 4.1e3, -1.3e3),
(-1.6e5, 1.9e5, -1.3e3, -4.1e3),
(-4.8e4, 1.6e4, -30.0, -88.0),
(1.6e4, 4.8e4, -88.0, 30.0),
)
)
hexapodArray20121020 = numpy.array(
(
(0.00e00, 1.07e05, 4.54e03, 0.00e00),
(1.18e05, -0.00e00, 0.00e00, -4.20e03),
(-4.36e04, 0.00e00, 0.00e00, -8.20e01),
(0.00e00, 4.42e04, -8.10e01, 0.00e00),
)
)
self.paramDict = {
"z4Conversion": 172.0,
"deltaZSetPoint": 0.0,
"alignmentMatrix": hexapodArray20121020,
"zPointsFile": "",
"z4PointsFile": "",
"z5PointsFile": "",
"z6PointsFile": "",
"z7PointsFile": "",
"z8PointsFile": "",
"z9PointsFile": "",
"z10PointsFile": "",
"z11PointsFile": "",
"z12PointsFile": "",
"z13PointsFile": "",
"z14PointsFile": "",
"z15PointsFile": "",
"nInterpGrid": 8,
"interpMethod": "idw",
"methodVal": None,
"donutCutString": "",
"sensorSet": "FandAOnly", # or "ScienceOnly" or "Mosaic"
"unVignettedOnly": False,
"doTrefoil": False,
"doSpherical": False,
"doQuadrefoil": False,
"doRzero": False,
"histFlag": False,
"debugFlag": False,
}
# update paramDict from inputDict
self.paramDict.update(inputDict)
# get DECam geometry information
if (
self.paramDict["sensorSet"] == "ScienceOnly"
or self.paramDict["sensorSet"] == "FandAOnly"
or self.paramDict["sensorSet"] == "PlusOnly"
or self.paramDict["sensorSet"] == "MinusOnly"
):
self.infoObj = decaminfo()
else:
print "HEY FOOL, set either ScienceOnly or FandAOnly !!!!"
exit()
self.infoObj = mosaicinfo()
self.info = self.infoObj.infoDict
# fill PointMesh coordinate list and gridDict
self.coordList = []
self.gridDict = {}
# Code for crude vignetting cut - now obsolete
if self.paramDict["unVignettedOnly"]:
limitsFA = {
"FS1": [0, 1024],
"FS2": [0, 1024],
"FS3": [0, 1024],
"FS4": [0, 1024],
"FN1": [-1024, 0],
"FN2": [-1024, 0],
"FN3": [-1024, 0],
"FN4": [-1024, 0],
}
else:
limitsFA = {
"FS1": [-1024, 1024],
"FS2": [-1024, 1024],
"FS3": [-1024, 1024],
"FS4": [-1024, 1024],
"FN1": [-1024, 1024],
"FN2": [-1024, 1024],
"FN3": [-1024, 1024],
"FN4": [-1024, 1024],
}
# build list of ccds - options are FandAOnly, ScienceOnly, All
if self.paramDict["sensorSet"] == "FandAOnly":
for ccd in self.info.keys():
ccdinfo = self.info[ccd]
if ccdinfo["FAflag"]:
self.coordList.append(ccd)
elif self.paramDict["sensorSet"] == "PlusOnly":
for ccd in self.info.keys():
ccdinfo = self.info[ccd]
if ccdinfo["FAflag"] and ccdinfo["Offset"] == 1500.0:
self.coordList.append(ccd)
elif self.paramDict["sensorSet"] == "MinusOnly":
for ccd in self.info.keys():
ccdinfo = self.info[ccd]
if ccdinfo["FAflag"] and ccdinfo["Offset"] == -1500.0:
self.coordList.append(ccd)
elif self.paramDict["sensorSet"] == "ScienceOnly":
for ccd in self.info.keys():
ccdinfo = self.info[ccd]
if not ccdinfo["FAflag"]:
self.coordList.append(ccd)
elif self.paramDict["sensorSet"] == "Both":
for ccd in self.info.keys():
self.coordList.append(ccd)
else:
print "donutana.py: HEY FOOL, you have to specify FandAOnly, ScienceOnly, or Both"
exit()
# reset doRzero based on sensorSet
if self.paramDict["sensorSet"] != "FandAOnly":
self.paramDict["doRzero"] = False
# loop over ccds
for ccd in self.coordList:
ccdinfo = self.info[ccd]
# either FA sensors or Science sensors
if ccdinfo["FAflag"]:
xlo = ccdinfo["xCenter"] - 1024 * self.infoObj.mmperpixel
xhi = ccdinfo["xCenter"] + 1024 * self.infoObj.mmperpixel
ylo = ccdinfo["yCenter"] - 1024 * self.infoObj.mmperpixel
yhi = ccdinfo["yCenter"] + 1024 * self.infoObj.mmperpixel
# fill gridDict
self.gridDict[ccd] = [self.paramDict["nInterpGrid"], ylo, yhi, self.paramDict["nInterpGrid"], xlo, xhi]
elif self.paramDict["sensorSet"] == "ScienceOnly" and not ccdinfo["FAflag"]:
xlo = ccdinfo["xCenter"] - 1024 * self.infoObj.mmperpixel
xhi = ccdinfo["xCenter"] + 1024 * self.infoObj.mmperpixel
ylo = ccdinfo["yCenter"] - 2048 * self.infoObj.mmperpixel
yhi = ccdinfo["yCenter"] + 2048 * self.infoObj.mmperpixel
# fill gridDict
# 1/31/2014 - make the grid x2 bigger in Y than X, to match CCD sizes!
self.gridDict[ccd] = [
2 * self.paramDict["nInterpGrid"],
ylo,
yhi,
self.paramDict["nInterpGrid"],
xlo,
xhi,
]
# elif self.paramDict["sensorSet"] == "Mosaic" :
# xlo = ccdinfo["xCenter"] - 1024 * self.infoObj.mmperpixel
# xhi = ccdinfo["xCenter"] + 1024 * self.infoObj.mmperpixel
# ylo = ccdinfo["yCenter"] - 2048 * self.infoObj.mmperpixel
# yhi = ccdinfo["yCenter"] + 2048 * self.infoObj.mmperpixel
#
# # fill gridDict
# self.gridDict[ccd] = [self.paramDict["nInterpGrid"],ylo,yhi,self.paramDict["nInterpGrid"],xlo,xhi]
# also keep a dictionary to the meshes
self.meshDict = {}
# for backward compatibility...
if self.paramDict["zPointsFile"] != "":
self.paramDict["z4PointsFile"] = self.paramDict["zPointsFile"]
# build the reference meshes
for iZ in range(4, 15 + 1):
name = "z%dPointsFile" % (iZ)
title = "Zernike %d" % (iZ)
if self.paramDict[name] != "":
theMesh = PointMesh(
self.coordList,
self.gridDict,
pointsFile=self.paramDict[name],
myMethod=self.paramDict["interpMethod"],
methodVal=self.paramDict["methodVal"],
title=title,
)
meshName = "z%dMesh" % iZ
self.meshDict[meshName] = theMesh
# matrix for Hexapod calculation
self.alignmentMatrix = numpy.matrix(self.paramDict["alignmentMatrix"])
self.alignmentMatrixSquared = numpy.matrix(
self.paramDict["alignmentMatrix"] * self.paramDict["alignmentMatrix"]
)
# store some constants
arcsecperrad = 3600.0 * 180.0 / numpy.pi
mmpermicron = 0.001
self.zangleconv = arcsecperrad * mmpermicron
