def __init__(self, mass, chi_sq_method='reduce'):
self.galaxies = get_galaxies()
self.shear = get_shear()
self.mass = mass
self.kappa = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin,
mass.ymax, mass.ny)
self.potiential = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin,
mass.ymax, mass.ny)
self.alpha = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin,
mass.ymax, mass.ny)
self.alphaX = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin,
mass.ymax, mass.ny)
self.alphaY = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin,
mass.ymax, mass.ny)
self.gamma = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin,
mass.ymax, mass.ny)
self.gamma1 = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin,
mass.ymax, mass.ny)
self.gamma2 = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin,
mass.ymax, mass.ny)
self.mag = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax,
mass.ny)
self.grid_arcsec = list()
self._findvalue_by_potential_fftw(mass)
self.chisq = 0
def GetKernels():
# This reads in kernels used for image manipulation
toppath = Config.toppath
datapathszekernel = toppath + 'data/sze/bullet_transfer_rescaled_small.fits'
datapathkernel60 = toppath + 'data/kernel60.dat'
datapathkernel20 = toppath + 'data/kernel20.dat'
datapathkernel15 = toppath + 'data/kernel15.dat'
szekernel = Array2d(0.0, 400.0, 113, 0.0, 400.0, 113)
datapathkernel5 = toppath + 'data/kernel5.dat'
szekernel = GetBulletFits(datapathszekernel, szekernel)
kernel60 = Array2d(0.0, 1.0, 110, 0.0, 1.0, 110)
kernel60 = GetBulletData(datapathkernel60, kernel60)
kernel20 = Array2d(0.0, 1.0, 110, 0.0, 1.0, 110)
kernel20 = GetBulletData(datapathkernel20, kernel20)
kernel15 = Array2d(0.0, 1.0, 110, 0.0, 1.0, 110)
kernel15 = GetBulletData(datapathkernel15, kernel15)
kernel5 = Array2d(0.0, 1.0, 110, 0.0, 1.0, 110)
kernel5 = GetBulletData(datapathkernel5, kernel5)
return (szekernel, kernel60, kernel20, kernel15, kernel5)
def ProjectEnzoTemp(pf,
mass,
phi=0.0,
theta=0.0,
psi=0.0,
zmin=-3000.0,
zmax=3000.0):
# Projects 3D Enzo data onto a 2D grid
# Returns mass data, Three Xray intensities, and SZ data.
start = time.time()
xpixels = mass.nx
ypixels = mass.ny
PixelArea = mass.dx * mass.dy
Temp = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax,
mass.ny)
SZ = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax, mass.ny)
BMag = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax,
mass.ny)
Synch = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax,
mass.ny)
add_field('TXRay',
function=_EnzoTXRay,
units=r"\rm{cm}^{-3}\rm{s}^{-1}",
projected_units=r"\rm{cm}^{-2}\rm{s}^{-1}",
validators=[ValidateParameter('ApecData')],
take_log=False)
add_field('XRay',
function=_EnzoXRay,
units=r"\rm{cm}^{-3}\rm{s}^{-1}",
projected_units=r"\rm{cm}^{-2}\rm{s}^{-1}",
validators=[ValidateParameter('ApecData')],
take_log=False)
add_field('BMag', function=_EnzoBMag, take_log=False)
add_field('Synch',
function=_EnzoSynch,
units=r"\rm{cm}^{-3}\rm{s}^{-1}",
projected_units=r"\rm{cm}^{-2}\rm{s}^{-1}",
take_log=False)
center = [(mass.xmin + mass.xmax) / 2.0, (mass.ymin + mass.ymax) / 2.0,
(zmin + zmax) / 2.0] # Data Center
normal_vector = (0.0, 0.0, 1.0)
north_vector = (0.0, 1.0, 0.0)
R = euler_angles(phi, theta, psi)
normal_vector = np.dot(R, normal_vector)
north_vector = np.dot(R, north_vector)
width = (mass.xmax - mass.xmin, mass.ymax - mass.ymin, zmax - zmin)
resolution = (mass.nx, mass.ny)
MassFactor = BulletConstants.cm_per_kpc**2 * PixelArea / (
BulletConstants.g_per_Msun * 1E10)
XFactor = BulletConstants.cm_per_kpc**2 * PixelArea * BulletConstants.AreaFactor
BFactor = 1.0 / (BulletConstants.cm_per_kpc * width[2])
SynchFactor = XFactor * BulletConstants.microJanskys_per_CGS
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"TXRay",
north_vector=north_vector,
pf=pf,
interpolated=True)
Temp.data = projcam.snapshot()[:, :]
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"XRay",
north_vector=north_vector,
pf=pf,
interpolated=True)
Temp.data = Temp.data / projcam.snapshot()[:, :]
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"BMag",
north_vector=north_vector,
pf=pf,
interpolated=True)
BMag.data = projcam.snapshot()[:, :] * BFactor
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"Synch",
north_vector=north_vector,
pf=pf,
interpolated=True)
Synch.data = projcam.snapshot()[:, :] * SynchFactor
elapsed = (time.time() - start)
print "Elapsed time to run Enzo temp projection = " + str(elapsed)
return [Temp, BMag, Synch]
def ProjectEnzoData(pf,
mass,
phi=0.0,
theta=0.0,
psi=0.0,
zmin=-3000.0,
zmax=3000.0,
DMProject=False):
# Projects 3D Enzo data onto a 2D grid
# Returns DM mass, Baryon mass, Three Xray intensities, and SZ data.
# DMProject = True runs a separate DM Projection.
# DMProject = False uses the yt raycasting.
# print 'PATH = ',os.environ['PATH']
# print 'PYTHONPATH = ',os.environ['PYTHONPATH']
# print 'LD_LIBRARY_PATH = ',os.environ['LD_LIBRARY_PATH']
# envir = Popen('env',shell=True, stdout = PIPE).communicate()[0].split('\n')
# print envir
DM = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax, mass.ny)
if DMProject:
print "Doing Separate DM Projection"
# DM = ProjectEnzoDM(pf, mass, 1, zmin, zmax, -psi, -theta, -phi)
else:
print "Skipping Separate DM Projection"
start = time.time()
xpixels = mass.nx
ypixels = mass.ny
PixelArea = mass.dx * mass.dy
# Mass density will go in the input 2d array.
# Will create additional 2d arrays for the Xray and SZ data
Xray1 = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax,
mass.ny)
Xray2 = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax,
mass.ny)
Xray3 = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax,
mass.ny)
SZ = Array2d(mass.xmin, mass.xmax, mass.nx, mass.ymin, mass.ymax, mass.ny)
add_field('XRay1',
function=_EnzoXRay1,
units=r"\rm{cm}^{-3}\rm{s}^{-1}",
projected_units=r"\rm{cm}^{-2}\rm{s}^{-1}",
validators=[ValidateParameter('ApecData')],
take_log=False)
add_field('XRay2',
function=_EnzoXRay2,
units=r"\rm{cm}^{-3}\rm{s}^{-1}",
projected_units=r"\rm{cm}^{-2}\rm{s}^{-1}",
validators=[ValidateParameter('ApecData')],
take_log=False)
add_field('XRay3',
function=_EnzoXRay3,
units=r"\rm{cm}^{-3}\rm{s}^{-1}",
projected_units=r"\rm{cm}^{-2}\rm{s}^{-1}",
validators=[ValidateParameter('ApecData')],
take_log=False)
add_field('SZ',
function=_EnzoSZ,
units=r"\rm{K}\rm{cm}^{-1}",
projected_units=r"\rm{K}",
take_log=False)
pf.field_info['Density'].take_log = False
pf.field_info['XRay1'].take_log = False
pf.field_info['XRay2'].take_log = False
pf.field_info['XRay3'].take_log = False
pf.field_info['SZ'].take_log = False
pf.field_info['Dark_Matter_Density'].take_log = False
center = [(mass.xmin + mass.xmax) / 2.0, (mass.ymin + mass.ymax) / 2.0,
(zmin + zmax) / 2.0] # Data Center
normal_vector = (0.0, 0.0, 1.0)
north_vector = (0.0, 1.0, 0.0)
R = euler_angles(phi, theta, psi)
normal_vector = np.dot(R, normal_vector)
north_vector = np.dot(R, north_vector)
width = (mass.xmax - mass.xmin, mass.ymax - mass.ymin, zmax - zmin)
resolution = (mass.nx, mass.ny)
MassFactor = BulletConstants.cm_per_kpc**2 * PixelArea / (
BulletConstants.g_per_Msun * 1E10)
XFactor = BulletConstants.cm_per_kpc**2 * PixelArea * BulletConstants.AreaFactor
if not DMProject:
print "Using yt Ray casting for DM"
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"Dark_Matter_Density",
north_vector=north_vector,
pf=pf,
interpolated=True)
DM.data = projcam.snapshot()[:, :] * MassFactor
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"Density",
north_vector=north_vector,
pf=pf,
interpolated=True)
mass.data = projcam.snapshot()[:, :] * MassFactor
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"XRay1",
north_vector=north_vector,
pf=pf,
interpolated=True)
Xray1.data = projcam.snapshot()[:, :] * XFactor
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"XRay2",
north_vector=north_vector,
pf=pf,
interpolated=True)
Xray2.data = projcam.snapshot()[:, :] * XFactor
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"XRay3",
north_vector=north_vector,
pf=pf,
interpolated=True)
Xray3.data = projcam.snapshot()[:, :] * XFactor
projcam = ProjectionCamera(center,
normal_vector,
width,
resolution,
"SZ",
north_vector=north_vector,
pf=pf,
interpolated=True)
SZ.data = projcam.snapshot()[:, :]
elapsed = (time.time() - start)
print "Elapsed time to run Enzo gas projection = " + str(elapsed)
return [DM, mass, Xray1, Xray2, Xray3, SZ]
def SimpleFom(pf,
data,
phi=0.0,
theta=0.0,
psi=0.0,
ConstrainPhi=True,
Mask=(1, 0, 0, 0, 0, 0, 0),
Z=1.0,
TFudge=1.0,
SpectralIndex=3.8,
MaxShift=0.0):
(dataA, sigmaA, maskA, maskANull, dataB1, sigmaB1, dataB2, sigmaB2, dataB3,
sigmaB3, dataC, sigmaC, dataD, sigmaD, maskD, maskDNull, dataE,
sigmaE) = data
mask_sum = maskA.data.sum()
# from save_to_pickle import picklesave, pickleread
# picklesave(dataA,sigmaA,maskA,maskANull,dataB1,sigmaB1,dataB2,sigmaB2,dataB3,sigmaB3,dataC,sigmaC,dataD,sigmaD,maskD,maskDNull,dataE,sigmaE,sumsim,xraysim1,xraysim2,xraysim3,szsim)
# pickleread()
try:
dmsim = Array2d(2.0 * dataA.xmin, 2.0 * dataA.xmax, 2 * dataA.nx,
2.0 * dataA.ymin, 2.0 * dataA.ymax, 2 * dataA.ny)
masssim = Array2d(2.0 * dataA.xmin, 2.0 * dataA.xmax, 2 * dataA.nx,
2.0 * dataA.ymin, 2.0 * dataA.ymax, 2 * dataA.ny)
sumsim = Array2d(2.0 * dataA.xmin, 2.0 * dataA.xmax, 2 * dataA.nx,
2.0 * dataA.ymin, 2.0 * dataA.ymax, 2 * dataA.ny)
ApecData = ReadLookups(Z) # Reads the APEC lookup tables.
for grid in pf.h.grids:
grid.set_field_parameter('ApecData', ApecData)
grid.set_field_parameter('TFudge', TFudge)
grid.set_field_parameter('SpectralIndex', SpectralIndex)
DMProject = False
[dmsim, masssim, xraysim1, xraysim2, xraysim3,
szsim] = ProjectEnzoData(pf,
masssim,
phi=phi,
theta=theta,
psi=psi,
DMProject=DMProject)
sumsim.data = gaussian_filter(dmsim.data + masssim.data, 2.0)
align = SetAlign(dataB1,
phi,
theta,
psi,
ConstrainPhi=ConstrainPhi,
MaxShift=MaxShift)
# The 0.22 is the approximate alignment of the bullet cluster on the sky.
tol = 1.0E-7 # Alignment tolerance
data1list = list((sumsim, xraysim1))
data2list = list((dataA, dataB1))
sigmalist = list((sigmaA, sigmaB1))
if Mask[1] == 1:
masklist = list((maskA, maskA))
else:
masklist = list((maskA, maskANull))
def get_items(optfunc):
if optfunc:
return optfunc.total_chiq_sq, optfunc.images_align.chi_sq_list[
1], optfunc.align.d[4]
else:
return 1E5, 1E5, 0
optfunc = FindBestShift(data1list, data2list, sigmalist, masklist,
align, tol)
(fom, xfom, phi) = get_items(optfunc)
return (fom, xfom, phi)
except:
print "Error in SimpleFom routine", sys.exc_info()[0]
return (1.0E5, 1.0E5, 0.0) # If there's an error, give it a large FOM
def FindBestShift(data1list, data2list, sigmalist, masklist, align, tol):
numarrays = len(data1list)
shifteddata1list = list()
for i in range(numarrays):
shifteddata1list.append(
Array2d(data2list[i].xmin, data2list[i].xmax, data2list[i].nx,
data2list[i].ymin, data2list[i].ymax, data2list[i].ny))
target = optfunc_massx(data1list, data2list, shifteddata1list, sigmalist,
masklist, align)
x0 = [align.d[0], align.d[1], align.d[4]]
kmax = 50
# def print_fun(x, f, accepted):
# print("at minimum %.4f accepted %d" % (f, int(accepted)))
class anealStep(object):
def __init__(self, stepsize=500, kmax=kmax, \
xmin=[align.dmin[0] / 2, align.dmin[1] / 2, align.dmin[4]], \
xmax=[align.dmax[0] / 2, align.dmax[1] / 2, align.dmax[4]]):
self.stepsize = stepsize
self.xmin = xmin
self.xmax = xmax
self.k = 0
def __call__(self, x):
s = self.stepsize
while True:
xnew = x.copy()
xnew[:-1] += np.random.uniform(-s, s, x[:-1].shape)
xnew[-1] += np.random.uniform(-np.pi, np.pi)
if np.all(xnew < self.xmax) and np.all(xnew > self.xmin):
break
self.k += 1
return xnew
SLSQPopt = {
'method':
'SLSQP',
'jac':
False,
'bounds': ((align.dmin[0] / 2, align.dmax[0] / 2),
(align.dmin[1] / 2, align.dmax[1] / 2), (align.dmin[4],
align.dmax[4])),
'tol':
1e-3
}
BHopts = {
'niter': 20,
'T': 5,
'stepsize': 50,
'interval': 1,
'minimizer_kwargs': SLSQPopt,
'take_step': anealStep(),
'disp': False,
'niter_success': 5,
'callback': None
}
try:
start = time.time()
bestfit = basinhopping(target.fit, x0, **BHopts)
elapsed_time = time.time() - start
print "Elapsed time to optimize chi_sq = {:.2f} chi_sq = {:.2f}".format(
elapsed_time, bestfit['fun'])
target.fom_compute(bestfit['x'])
return target
except Exception, err:
print "Error in basinhopping routine",
exc_info = sys.exc_info()
traceback.print_exception(*exc_info)
####### Issue
return None # If there's an error, give it a large FOM
def BestPlot(snap,
Z,
phi=0.0,
theta=0.0,
psi=0.0,
PlotSuffix='New_Kappa',
FomLocate=False,
TFudge=1.0,
ConstrainPhi=False,
Mask=(1, 0, 0, 0, 0, 0),
SpectralIndex=3.2,
MaxShift=0.0):
(dataA, sigmaA, maskA, maskANull, dataB1, sigmaB1, dataB2, sigmaB2, dataB3,
sigmaB3, dataC, sigmaC, dataD, sigmaD, maskD, maskDNull, dataE,
sigmaE) = GetData()
(szekernel, kernel60, kernel20, kernel15, kernel5) = GetKernels()
[dyyA, dxxA] = np.meshgrid(dataA.y, dataA.x) # Data grid for plots
[dyyB, dxxB] = np.meshgrid(dataB1.y, dataB1.x) # Data grid for plots
[dyyD, dxxD] = np.meshgrid(dataD.y, dataD.x) # Data grid for plots
align = SetAlign(dataB1,
phi,
theta,
psi,
ConstrainPhi=ConstrainPhi,
MaxShift=MaxShift)
pp = PdfPages('output/Graph_' + PlotSuffix + '.pdf')
pf = GetPF(snap)
add_field("BMag", function=_EnzoBMag)
simtime = pf.h.parameters[
'InitialTime'] * BulletConstants.TimeConversion # Put time in Gyears
dmsim = Array2d(2.0 * dataA.xmin, 2.0 * dataA.xmax, 2 * dataA.nx,
2.0 * dataA.ymin, 2.0 * dataA.ymax, 2 * dataA.ny)
masssim = Array2d(2.0 * dataA.xmin, 2.0 * dataA.xmax, 2 * dataA.nx,
2.0 * dataA.ymin, 2.0 * dataA.ymax, 2 * dataA.ny)
sumsim = Array2d(2.0 * dataA.xmin, 2.0 * dataA.xmax, 2 * dataA.nx,
2.0 * dataA.ymin, 2.0 * dataA.ymax, 2 * dataA.ny)
tempmass = Array2d(2.0 * dataD.xmin, 2.0 * dataD.xmax, 2 * dataD.nx,
2.0 * dataD.ymin, 2.0 * dataD.ymax, 2 * dataD.ny)
[syyA, sxxA] = np.meshgrid(dmsim.y, dmsim.x) # Sim grid for plots
[syyD, sxxD] = np.meshgrid(tempmass.y, tempmass.x) # Sim grid for plots
ApecData = ReadLookups(Z) # Reads the APEC lookup tables.
for grid in pf.h.grids:
grid.set_field_parameter('ApecData', ApecData)
grid.set_field_parameter('TFudge', TFudge)
grid.set_field_parameter('SpectralIndex', SpectralIndex)
DMProject = False
[dmsim, masssim, xraysim1, xraysim2, xraysim3,
szsim] = ProjectEnzoData(pf,
masssim,
phi=phi,
theta=theta,
psi=psi,
DMProject=DMProject)
sumsim.data = gaussian_filter(dmsim.data + masssim.data, 2.0)
szsim.data = convolve(
abs(szsim.data * 1E6), szekernel.data, mode='constant',
cval=0.0) # Smooth simulation with given transfer function
# xraysim1.data=convolve(xraysim1.data,kernel5.data,mode='constant',cval=0.0)#Smooth simulation with given transfer function
# xraysim2.data=convolve(xraysim2.data,kernel5.data,mode='constant',cval=0.0)#Smooth simulation with given transfer function
# xraysim3.data=convolve(xraysim3.data,kernel5.data,mode='constant',cval=0.0)#Smooth simulation with given transfer function
[tempsim, bmagsim, synchsim] = ProjectEnzoTemp(pf,
tempmass,
phi=phi,
theta=theta,
psi=psi)
synchsim.data = convolve(
synchsim.data, kernel20.data, mode='constant',
cval=0.0) # Smooth simulation with given transfer function
BMax = pf.h.sphere(
(0, 0, 0),
(1000.0, "kpc")).quantities["MaxLocation"]("BMag")[0] * 1.0E6
BMin = pf.h.sphere(
(0, 0, 0),
(1000.0, "kpc")).quantities["MinLocation"]("BMag")[0] * 1.0E6
print "Bmax = %.4g, Bmin = %.4g\n" % (BMax, BMin)
sys.stdout.flush()
# sys.exit()
# Projected Enzo sim data
tol = 1.0E-7 # Alignment tolerance
data1list = list((sumsim, xraysim1, xraysim2, xraysim3, szsim, tempsim,
synchsim, bmagsim))
data2list = list(
(dataA, dataB1, dataB2, dataB3, dataC, dataD, dataE, dataE))
sigmalist = list(
(sigmaA, sigmaB1, sigmaB2, sigmaB3, sigmaC, sigmaD, sigmaE, sigmaE))
masklist = list()
# This code appends the necessary masks. If Mask[i]==0, this data is not included in the FOM
for i in range(5):
if Mask[i] == 0:
masklist.append((maskANull))
print "i = %d, Mask[i] = %d, appending maskAnull\n" % (i, Mask[i])
else:
masklist.append((maskA))
print "i = %d, Mask[i] = %d, appending maskA\n" % (i, Mask[i])
if Mask[5] == 0:
masklist.append((maskDNull))
print "i = 5, Mask[i] = %d, appending maskDNull\n" % Mask[i]
else:
masklist.append(maskD)
print "i = 5, Mask[i] = %d, appending maskD\n" % Mask[i]
masklist.append(maskANull) # Always mask the radio
masklist.append(maskANull) # Always mask the radio bmag
sys.stdout.flush()
def get_item(optfunc):
if optfunc is None:
print "Optimization Fail, Try again"
exit()
else:
return optfunc.images_align.shifteddata1list, optfunc.align, optfunc.total_chiq_sq
optfunc = FindBestShift(data1list, data2list, sigmalist, masklist, align,
tol)
pickle_output = open('output/optfunc.pkl', 'wb')
pickle.dump(optfunc, pickle_output)
pickle_output.close()
print "Done with pickle"
sys.stdout.flush()
(shifteddata1list, align, fom) = get_item(optfunc)
shiftedmsim = shifteddata1list[0]
shiftedxsim1 = shifteddata1list[1]
shiftedxsim2 = shifteddata1list[2]
shiftedxsim3 = shifteddata1list[3]
shiftedszsim = shifteddata1list[4]
shiftedtempsim = shifteddata1list[5]
shiftedsynchsim = shifteddata1list[6]
shiftedbmagsim = shifteddata1list[7]
MassWithin250 = EnclosedMass(dataA, 250)
print "Main Data Mass within250 = %f, Bullet Data Mass Within250 = %f\n" % (
MassWithin250[0], MassWithin250[1])
MassWithin250 = EnclosedMass(shiftedmsim, 250)
print "Main Sim Mass within250 = %f, Bullet Sim Mass Within250 = %f\n" % (
MassWithin250[0], MassWithin250[1])
try:
[filled_levels, line_levels] = SetContourLevels(0.0, 70.0)
fig = ComparisonPlot(dataA,
shiftedmsim,
"Mass Lensing",
filled_levels=filled_levels,
line_levels=line_levels,
simtime=simtime,
fom=fom,
line=[80, 53, 0.26],
legend_location=[0.80, 0.3],
line_plot_yticks=[0.0, 20.0, 40.0, 60.0])
pp.savefig(fig)
fig.savefig('output/mass_lensing.png')
[filled_levels, line_levels] = SetContourLevels(-10.0, -4.0)
fig = ComparisonPlot(dataB1,
shiftedxsim1,
"X-ray Flux - 500-2000eV",
filled_levels=filled_levels,
line_levels=line_levels,
cmap=cm.spectral,
simtime=simtime,
fom=fom,
line=[70, 55, 0.24],
legend_location=[0.50, 1.0],
line_plot_yticks=[0.0, 1.0, 2.0, 3.0],
line_plot_multiplier=1.0E6,
take_log=True)
pp.savefig(fig)
fig.savefig('output/mass_lensing.png')
fig = ComparisonPlot(dataB2,
shiftedxsim2,
"X-ray Flux - 2000-5000eV",
filled_levels=filled_levels,
line_levels=line_levels,
cmap=cm.spectral,
simtime=simtime,
fom=fom,
line=[70, 55, 0.24],
legend_location=[0.50, 1.0],
line_plot_yticks=[0.0, 0.5, 1.0],
line_plot_multiplier=1.0E6,
take_log=True)
pp.savefig(fig)
fig.savefig('output/xray_bin1.png')
fig = ComparisonPlot(dataB3,
shiftedxsim3,
"X-ray Flux - 5000-8000eV",
filled_levels=filled_levels,
line_levels=line_levels,
cmap=cm.spectral,
simtime=simtime,
fom=fom,
line=[70, 55, 0.24],
legend_location=[0.50, 1.0],
line_plot_yticks=[0.0, 1.0, 2.0, 3.0],
line_plot_multiplier=1.0E7,
take_log=True)
pp.savefig(fig)
fig.savefig('output/xray_bin2.png')
[filled_levels, line_levels] = SetContourLevels(-10.0, -4.0)
fig = MultiLinePlot(dataB1,
shiftedxsim1,
"X-ray Flux - 500-2000eV",
filled_levels=filled_levels,
line_levels=line_levels,
cmap=cm.spectral,
simtime=simtime,
fom=fom,
line1=[78, 56, -0.24],
line2=[78, 56, 0.24],
line3=[78, 56, 1.02],
legend_location1=[0.70, 0.30],
legend_location2=[0.70, 0.30],
legend_location3=[0.70, 0.30],
line_plot_yticks=[-8.0, -7.0, -6.0],
take_log=True)
pp.savefig(fig)
fig.savefig('output/xray_bin3.png')
[filled_levels, line_levels] = SetContourLevels(-10.0, -4.0)
ED_filled_levels = np.linspace(0, 10.0, 11)
ED_line_levels = np.linspace(1.0, 5.0, 5)
(fig, efom) = EdgeDetectionPlot(dataB1,
shiftedxsim1,
"X-ray Shock Edge Detection",
filled_levels=filled_levels,
ED_filled_levels=ED_filled_levels,
ED_line_levels=ED_line_levels,
ED_multiplier=1.0E7,
cmap=cm.spectral,
simtime=simtime,
fom=fom,
take_log=True)
pp.savefig(fig)
fig.savefig('output/xray_edge_detect.png')
[filled_levels, line_levels] = SetContourLevels(0.0, 20.0)
fig = ComparisonPlot(dataD,
shiftedtempsim,
"Gas Temperature (keV)",
filled_levels=filled_levels,
line_levels=line_levels,
cmap=cm.spectral,
simtime=simtime,
fom=fom,
line=[70, 52, 0.24],
legend_location=[0.60, 1.0],
line_plot_yticks=[5.0, 10.0, 15.0])
pp.savefig(fig)
fig.savefig('output/gas_temperature.png')
[filled_levels, line_levels] = SetContourLevels(0.0, 500.0)
fig = ComparisonPlot(dataC,
shiftedszsim,
"SZ Temperature Decrement ($\mu K$)",
filled_levels=filled_levels,
line_levels=line_levels,
simtime=simtime,
fom=fom,
line=[70, 59, 0.24],
legend_location=[0.70, 0.32],
line_plot_yticks=[0.0, 100.0, 200.0, 300.0])
pp.savefig(fig)
fig.savefig('output/sz_temperature.png')
filled_levels = [0.0, 6.0, 12.0, 24.0, 36.0, 48.0, 96.0]
line_levels = [0.0, 6.0, 12.0, 24.0, 36.0, 48.0, 96.0]
fig = ComparisonPlot(dataE,
shiftedsynchsim,
"Radio Flux - 1.3 GHz ($\mu$ Jy / pixel)",
filled_levels=filled_levels,
line_levels=line_levels,
cmap=cm.spectral,
simtime=simtime,
fom=fom,
line=[70, 59, 0.24],
legend_location=[1.10, 1.0],
line_plot_yticks=[0.0, 25.0, 50.0, 75.0])
pp.savefig(fig)
fig.savefig('output/radioflux.png')
if FomLocate:
numpixels = dataA.nx * dataA.ny
masschisquared = pow(
(dataA.data - shiftedmsim.data) / sigmaA.data, 2) * maskA.data
xray1chisquared = pow(
(dataB1.data - shiftedxsim1.data) / sigmaB1.data,
2) * maskA.data
xray2chisquared = pow(
(dataB2.data - shiftedxsim2.data) / sigmaB2.data,
2) * maskA.data
xray3chisquared = pow(
(dataB3.data - shiftedxsim3.data) / sigmaB3.data,
2) * maskA.data
szechisquared = pow(
(dataC.data - shiftedszsim.data) / sigmaC.data, 2) * maskA.data
tempchisquared = pow(
(dataD.data - shiftedtempsim.data) / sigmaD.data,
2) * maskD.data
mask_sum = maskA.data.sum()
datasets = [
masschisquared, xray1chisquared, xray2chisquared,
xray3chisquared, tempchisquared, szechisquared
]
plotsets = [dataA, dataB1, dataB2, dataB3, dataD, dataC]
subtitles = [
"Mass", "X-ray 1", "X-ray 2", "X-ray 3", "Temp", "SZE"
]
fig = FomLocationPlot(datasets,
subtitles,
plotsets,
mask_sum,
cmap=cm.spectral,
simtime=simtime,
fom=fom)
pp.savefig(fig)
fig.savefig('output/fomlocal.png')
print "Finished plots for snapshot file", snap, "\n"
sys.stdout.flush()
except:
print "Unexpected error in plot routines.\n"
print "sys.exc_info=", sys.exc_info(), "\n"
pp.close()
return 0
pp.close()
return efom
def GetData():
# This reads in the image data
toppath = Config.toppath
datapathA = toppath + 'data/kappa_25Apr12.dat'
datapathB1 = toppath + 'data/xray_500_2000_29Jun11.dat'
datapathB2 = toppath + 'data/xray_2000_5000_29Jun11.dat'
datapathB3 = toppath + 'data/xray_5000_8000_29Jun11.dat'
datapathC = toppath + 'data/sze_data_13Mar13.dat'
datapathD = toppath + 'data/xray_temp_23Jun11.dat'
datapathE = toppath + 'data/radio_24Apr13.dat'
datapathsA = toppath + 'data/mass_sigma_11Feb13.dat'
datapathsB1 = toppath + 'data/xray_sigma_500_2000_18Jul11.dat'
datapathsB2 = toppath + 'data/xray_sigma_2000_5000_18Jul11.dat'
datapathsB3 = toppath + 'data/xray_sigma_5000_8000_18Jul11.dat'
datapathsC = toppath + 'data/sze_sigma_13Mar13.dat'
datapathsD = toppath + 'data/xray_temp_sigma_23Jun11.dat'
datapathsE = toppath + 'data/radio_sigma_5Oct11.dat'
datapathmA = toppath + 'data/mask_3May12.dat'
datapathmANull = toppath + 'data/mask_23Jun11_null.dat'
datapathmD = toppath + 'data/xtemp_mask_23Jun11.dat'
datapathmDNull = toppath + 'data/xtemp_mask_null_29Jun11.dat' # Ignore temp in this case.
# First, the Mass data - designated as A
xscaleA = yscaleA = BulletConstants.AngularScale * 3600 * BulletConstants.MassDataScale
# Pixel size in kpc. 4.413 kpc/" is the angular scale at the bullet cluster
# 3600 "/degree, 9.86E-4 degrees/pixel is the data scale
xpixelsA = ypixelsA = 110
sxpixelsA = sypixelsA = 220
dxmaxA = xscaleA * xpixelsA / 2
dymaxA = yscaleA * ypixelsA / 2
dxminA = -xscaleA * xpixelsA / 2
dyminA = -yscaleA * ypixelsA / 2
sxmaxA = xscaleA * xpixelsA
symaxA = yscaleA * ypixelsA
dataA = Array2d(dxminA, dxmaxA, xpixelsA, dyminA, dymaxA, ypixelsA)
dataA = GetBulletData(datapathA, dataA) # Mass density measured data
sigmaA = Array2d(dxminA, dxmaxA, xpixelsA, dyminA, dymaxA, ypixelsA)
sigmaA = GetBulletData(datapathsA, sigmaA) # Mass sigma
# sigmaA.data = sigmaA.data / 2.0 # Arbitrarily reduce mass sigma to improve mass fit.
maskA = Array2d(dxminA, dxmaxA, xpixelsA, dyminA, dymaxA, ypixelsA)
maskA = GetBulletData(datapathmA, maskA) # Mask
maskANull = Array2d(dxminA, dxmaxA, xpixelsA, dyminA, dymaxA, ypixelsA)
maskANull = GetBulletData(datapathmANull, maskANull) # Null Mask
xscaleB = yscaleB = BulletConstants.AngularScale * 3600 * BulletConstants.XRayDataScale
# Pixel size in kpc. 4.413 kpc/" is the angular scale at the bullet cluster
# 3600 "/degree, 9.86E-4 degrees/pixel is the data scale
xpixelsB = ypixelsB = 110
sxpixelsB = sypixelsB = 220
dxmaxB = xscaleB * xpixelsB / 2
dymaxB = yscaleB * ypixelsB / 2
sxmaxB = dxmaxB * 2
symaxB = dymaxB * 2
dataB1 = Array2d(-dxmaxB, dxmaxB, xpixelsB, -dymaxB, dymaxB, ypixelsB)
dataB1 = GetBulletData(datapathB1, dataB1) # XRay measured data
sigmaB1 = Array2d(-dxmaxB, dxmaxB, xpixelsB, -dymaxB, dymaxB, ypixelsB)
sigmaB1 = GetBulletData(datapathsB1, sigmaB1) # XRay sigma
dataB2 = Array2d(-dxmaxB, dxmaxB, xpixelsB, -dymaxB, dymaxB, ypixelsB)
dataB2 = GetBulletData(datapathB2, dataB2) # XRay measured data
sigmaB2 = Array2d(-dxmaxB, dxmaxB, xpixelsB, -dymaxB, dymaxB, ypixelsB)
sigmaB2 = GetBulletData(datapathsB2, sigmaB2) # XRay sigma
dataB3 = Array2d(-dxmaxB, dxmaxB, xpixelsB, -dymaxB, dymaxB, ypixelsB)
dataB3 = GetBulletData(datapathB3, dataB3) # XRay measured data
sigmaB3 = Array2d(-dxmaxB, dxmaxB, xpixelsB, -dymaxB, dymaxB, ypixelsB)
sigmaB3 = GetBulletData(datapathsB3, sigmaB3) # XRay sigma
# dataB.data=gaussian_filter(dataB.data,0.5)
# 0.5-sigma smoothing of X-Ray data
dataC = Array2d(dxminA, dxmaxA, xpixelsA, dyminA, dymaxA, ypixelsA)
dataC = GetBulletData(datapathC, dataC) # Measured SZE data
sigmaC = Array2d(dxminA, dxmaxA, xpixelsA, dyminA, dymaxA, ypixelsA)
# sigmaC=GetBulletData(datapathsC,sigmaC)# SZE Sigma
sigmaC.data = sigmaC.data + 25.0E-6 # Set to 25 microKelvin based on Plagge et.al.
dataC.data = abs(dataC.data * 1E6) # convert to micro Kelvin
sigmaC.data = sigmaC.data * 1E6 # convert to micro Kelvin
xscaleD = yscaleD = BulletConstants.AngularScale * 3600 * BulletConstants.XRayTempDataScale
# Pixel size in kpc. 4.413 kpc/" is the angular scale at the bullet cluster
# 3600 "/degree, 1.09333 degrees/pixel is the data scale
xpixelsD = ypixelsD = 100
sxpixelsD = sypixelsD = 200
dxmaxD = xscaleD * xpixelsD / 2
dymaxD = yscaleD * ypixelsD / 2
sxmaxD = dxmaxD * 2
symaxD = dymaxD * 2
dataD = Array2d(-dxmaxD, dxmaxD, xpixelsD, -dymaxD, dymaxD, ypixelsD)
dataD = GetBulletData(datapathD, dataD) # XRay measured data
sigmaD = Array2d(-dxmaxD, dxmaxD, xpixelsD, -dymaxD, dymaxD, ypixelsD)
sigmaD = GetBulletData(datapathsD, sigmaD) # Xray Temp Sigma
maskD = Array2d(-dxmaxD, dxmaxD, xpixelsD, -dymaxD, dymaxD, ypixelsD)
maskD = GetBulletData(datapathmD, maskD) # Mask
maskDNull = Array2d(-dxmaxD, dxmaxD, xpixelsD, -dymaxD, dymaxD, ypixelsD)
maskDNull = GetBulletData(datapathmDNull, maskDNull) # Null Mask
dataE = Array2d(-dxmaxA, dxmaxA, xpixelsA, -dymaxA, dymaxA, ypixelsA)
sigmaE = Array2d(-dxmaxA, dxmaxA, xpixelsA, -dymaxA, dymaxA, ypixelsA)
dataE = GetBulletData(datapathE, dataE) # Radio measured data
sigmaE = GetBulletData(datapathsE, sigmaE) # Radio Sigma
return (dataA, sigmaA, maskA, maskANull, dataB1, sigmaB1, dataB2, sigmaB2,
dataB3, sigmaB3, dataC, sigmaC, dataD, sigmaD, maskD, maskDNull,
dataE, sigmaE)