def main():
phi_lats = [i * 45.0 for i in range(8)]
theta_lats = [i for i in range(int(settings.THETA_LAT_CUTOFF) + 1)]
energy_mid_bins = np.logspace(
-2, 4, 100, base=10.0) # getEnergyMidBins(1e-2, 1e4, 100)
print(energy_mid_bins)
pyIrfLoader.Loader_go()
myFactory = pyIrfLoader.IrfsFactory_instance()
irfs_f = myFactory.create("%s::FRONT" % settings.IRF_NAME)
irfs_b = myFactory.create("%s::BACK" % settings.IRF_NAME)
aeff_f = irfs_f.aeff()
aeff_b = irfs_b.aeff()
for energy_mid_bin in energy_mid_bins:
eff_front = aeff_f.value(GEV_TO_MEV * energy_mid_bin, FIX_THETA_LAT,
FIX_PHI_LAT) / CM2_TO_M2
eff_back = aeff_b.value(GEV_TO_MEV * energy_mid_bin, FIX_THETA_LAT,
FIX_PHI_LAT) / CM2_TO_M2
eff = eff_front + eff_back
LOG_EFF_FRONT.append(eff_front)
LOG_EFF_BACK.append(eff_back)
LOG_EFF.append(eff)
# visualize
plt.plot(energy_mid_bins, LOG_EFF_FRONT, 'ro-', label="FRONT")
plt.plot(energy_mid_bins, LOG_EFF_BACK, 'bo-', label="BACK")
plt.plot(energy_mid_bins, LOG_EFF, 'ko-', label="TOTAL")
plt.legend()
plt.title('%s eff area (THETA_LAT %d deg, PHI_LAT %d deg)' %
(settings.IRF_NAME, FIX_THETA_LAT, FIX_PHI_LAT))
plt.xlabel('E (GeV)')
plt.xscale('log')
plt.ylabel('Effective area ($m^2$)')
plt.savefig('eff_energy_dist.png')
def main():
phi_lats = [i * 45.0 for i in range(8)]
theta_lats = [i for i in range(int(settings.THETA_LAT_CUTOFF) + 1)]
energy_mid_bins = getEnergyMidBins()
pyIrfLoader.Loader_go()
myFactory = pyIrfLoader.IrfsFactory_instance()
irfs_f = myFactory.create("%s::FRONT" % settings.IRF_NAME)
irfs_b = myFactory.create("%s::BACK" % settings.IRF_NAME)
aeff_f = irfs_f.aeff()
aeff_b = irfs_b.aeff()
for energy_mid_bin in energy_mid_bins:
f_eff = open(
os.path.join(PATH_SAVE_EFF,
"eff_E%d.csv" % (int(math.floor(energy_mid_bin)))),
"w")
f_eff.write("theta_lat,eff_m2\n")
for theta_lat in theta_lats:
for phi_lat in phi_lats:
eff = []
eff_front = aeff_f.value(GEV_TO_MEV * energy_mid_bin,
theta_lat, phi_lat) / CM2_TO_M2
eff_back = aeff_b.value(GEV_TO_MEV * energy_mid_bin, theta_lat,
phi_lat) / CM2_TO_M2
eff.append(eff_front + eff_back)
mean_eff = sum(eff) / len(eff)
f_eff.write("%f,%f\n" % (theta_lat, mean_eff))
f_eff.close()
def AeffPhiDepPlot(IRFs,
nph,
energy,
theta,
front=True,
back=False,
plot=True):
#get phi points
phis = [0 + i * (90. / (nph - 1.)) for i in range(nph)]
#access available IRFs
pyIrfLoader.Loader_go()
if front and back:
#get front and back IRFs, get effective area for phis for given energy and theta
conv = 'FRONT + BACK'
irfs_front = pyIrfLoader.IrfsFactory.instance().create(IRFs +
"::FRONT")
irfs_back = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::BACK")
Aeff_front = getAeff_phi(irfs_front.aeff(), energy, theta, phis)
Aeff_back = getAeff_phi(irfs_back.aeff(), energy, theta, phis)
Aeff = Aeff_front + Aeff_back
else:
#access the necessary IRFs, get effective area for phis for given energy and theta
conv = ('FRONT' if front else "BACK")
irfs = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::" + conv)
Aeff = getAeff_phi(irfs.aeff(), energy, theta, phis)
#expand the phi values out to 360 degrees, copy effective area values too
phibins = array(phis + [p + 90.
for p in phis[1:]] + [p + 180. for p in phis[1:]] +
[p + 270. for p in phis[1:]])
AeffValues = array([a for a in Aeff] + [a for a in Aeff[1:]] +
[a for a in Aeff[1:]] + [a for a in Aeff[1:]])
#make and fill phi graph
phigraph = TGraph(len(phibins), phibins, AeffValues)
phigraph.SetMarkerStyle(20)
phigraph.SetMarkerColor(1)
phigraph.SetLineColor(1)
if plot:
#if plot set to True, draw and make some style choices
phcan = TCanvas(
'phcan',
'%s %s Effective Area vs. phi for E = %.1f MeV and theta = %.1f deg'
% (IRFs, conv, energy, theta), 1000, 800)
phcan.SetTicks(1, 1)
pdummy = TH1F('pdummy', '', 1000, 0, 360)
pdummy.SetXTitle('#phi (#circ)')
pdummy.GetXaxis().CenterTitle()
pdummy.SetYTitle('A_{eff} (m^{2} )')
pdummy.GetYaxis().CenterTitle()
pdummy.GetYaxis().SetRangeUser(0., 1.)
pdummy.Draw()
phigraph.Draw('plsame')
SetOwnership(phigraph, False)
SetOwnership(phcan, False)
SetOwnership(pdummy, False)
return phigraph
def createFromPyIRF(irf_name):
"""Create IRF object using pyIrf modules in Science Tools."""
import pyIrfLoader
if not IRFManager.load_irf:
pyIrfLoader.Loader_go()
IRFManager.load_irf = True
irf_factory=pyIrfLoader.IrfsFactory.instance()
irfs = irf_factory.create(irf_name)
psf = PSFPyIRF(irfs.psf())
aeff = AeffPyIRF(irfs.aeff())
edisp = EDispPyIRF(irfs.edisp())
return IRF(psf,aeff,edisp)
directions.
@author J. Chiang <*****@*****.**>
"""
# @file psf_tests.py
# $Header: /nfs/slac/g/glast/ground/cvs/ScienceTools-scons/irfs/pyIrfLoader/python/psf_tests.py,v 1.1.1.1 2006/10/24 19:42:15 jchiang Exp $
#
import os, sys, bisect
import numarray as num
import hippoplotter as plot
import pyIrfLoader as irf_loader
#from Interpolator import Interpolator
from ks import ks1, ks2
irf_loader.Loader_go()
SkyDir = irf_loader.SkyDir
class Psf(object):
_factory = irf_loader.IrfsFactory_instance()
def __init__(self, irfsName, energy=100., inc=0, phi=0):
self._irfs = self._factory.create(irfsName)
self._psf = self._irfs.psf()
self._energy = energy
self._inc = inc
self._phi = phi
def __call__(self, separation):
# Licensed under a 3-clause BSD style license - see LICENSE.rst
from __future__ import absolute_import, division, print_function
import copy
from functools import wraps
import numpy as np
import pyLikelihood as pyLike
from SrcModel import SourceModel
from AnalysisBase import AnalysisBase
from LikelihoodState import LikelihoodState
import pyIrfLoader
pyIrfLoader.Loader_go()
_funcFactory = pyLike.SourceFactory_funcFactory()
import BinnedAnalysis as ba
import SummedLikelihood
from fermipy import utils
from fermipy import model_utils
evtype_string = {4: 'PSF0', 8: 'PSF1', 16: 'PSF2', 32: 'PSF3'}
def bitmask_to_bits(mask):
bits = []
for i in range(32):
if mask & (2**i):
bits += [2**i]
def comp_exposure_phi_new(gta, energy=None, nevt_max=None):
"""
Compute the approximate exposure
trying to speed things up on 09/21/2020
Parameters
----------
gta: `~fermipy.GTAnalysis`
The analysis object
{options}
energy: float or None
The energy at which the exposure is evaluated.
If none, central energy from selection is used
"""
from tqdm import tqdm
# load the effective areas
irf_loader.Loader_go()
irfs = gta.config['gtlike']['irfs']
factory = irf_loader.IrfsFactory_instance()
fronta = factory.create(irfs + "::FRONT")
backa = factory.create(irfs + "::BACK")
aeff_fa = fronta.aeff()
aeff_ba = backa.aeff()
if type(energy) == type(None):
energy = float(np.sqrt(gta.config['selection']['emin'] * \
gta.config['selection']['emax']))
# load the FT1 and FT2 files
ft1fits = fits.open(gta.config['data']['evfile'])
ft2fits = fits.open(gta.config['data']['scfile'])
TSTART = float(ft1fits['EVENTS'].header["TSTART"]) - 30.
TSTOP = float(ft1fits['EVENTS'].header["TSTOP"]) + 30.
nevt = int(ft2fits['SC_DATA'].header['NAXIS2']) if nevt_max is None else nevt_max
src = gta.roi[gta.config['selection']['target']]
c0 = SkyCoord(ra = src.radec[0],dec = src.radec[1], unit = 'deg')
# the GTIs from the FT1 file
ft1_gti_start = ft1fits['GTI'].data.field('START')
ft1_gti_stop = ft1fits['GTI'].data.field('STOP')
# central times of GTI in SC file
tcen = 0.5 * (ft2fits['SC_DATA'].data.field("START") + \
ft2fits['SC_DATA'].data.field("STOP"))
mask = (tcen > TSTART) & (tcen < TSTOP)
# Spacecraft coordinates
cz = SkyCoord(ra = ft2fits['SC_DATA'].data.field('RA_SCZ'),
dec = ft2fits['SC_DATA'].data.field('DEC_SCZ'),
unit = 'deg')
cx = SkyCoord(ra = ft2fits['SC_DATA'].data.field('RA_SCX'),
dec = ft2fits['SC_DATA'].data.field('DEC_SCX'),
unit = 'deg')
czen = SkyCoord(ra = ft2fits['SC_DATA'].data.field('RA_ZENITH'),
dec = ft2fits['SC_DATA'].data.field('DEC_ZENITH'),
unit = 'deg')
sep_z0 = c0.separation(cz)
sep_zenith0 = c0.separation(czen)
id = np.cos(np.radians(sep_z0))
# compute phi direction to src in SC coordinates
phi = get_phi(cz = cz, cx = cx, c0 = c0)
# livetime
livetime = ft2fits['SC_DATA'].data.field('LIVETIME')
# loop over GTIs in SC file
af, ab = np.zeros(nevt), np.zeros(nevt)
logging.info("Calculating exposure for E = {0:.2f} MeV".format(energy))
mask = mask & (sep_zenith0.value <= gta.config['selection']['zmax'])
t1 = time.time()
for i in tqdm(range(nevt)):
if not mask[i]: continue
#igti = 0
# find the right GTI for the considered SC GTI
#while igti < ft1_gti_start.size and ft1_gti_start[igti] < tcen[i]:
#igti += 1
#if igti >= ft1_gti_start.size:
#break
m1 = tcen[i] >= ft1_gti_start
m2 = tcen[i] < ft1_gti_stop
if not (m1 & m2).sum():
continue
# if tcen[i] > ft1_gti_start[igti - 1] and tcen[i] < ft1_gti_stop[igti - 1]:
# af[i] = aeff_fa.value(energy,
# float(sep_z0[i].value),
# float(phi[i])) *livetime[i]
# ab[i] = aeff_ba.value(energy,
# float(sep_z0[i].value),
# float(phi[i])) *livetime[i]
af[i] = aeff_fa.value(energy,
float(sep_z0[i].value),
float(phi[i])) *livetime[i]
ab[i] = aeff_ba.value(energy,
float(sep_z0[i].value),
float(phi[i])) *livetime[i]
print ("it took {0:.2f}s".format(time.time() - t1))
logging.info("Done")
return tcen,af,ab
def comp_exposure_phi_v2(gta, energy = None):
"""
Compute the approximate exposure
Parameters
----------
gta: `~fermipy.GTAnalysis`
The analysis object
{options}
energy: float or None
The energy at which the exposure is evaluated.
If none, central energy from selection is used
"""
# load the effective areas
irf_loader.Loader_go()
irfs = gta.config['gtlike']['irfs']
factory = irf_loader.IrfsFactory_instance()
fronta = factory.create(irfs + "::FRONT")
backa = factory.create(irfs + "::BACK")
aeff_fa = fronta.aeff()
aeff_ba = backa.aeff()
if type(energy) == type(None):
energy = float(np.sqrt(gta.config['selection']['emin'] * \
gta.config['selection']['emax']))
# load the FT1 and FT2 files
ft1fits = fits.open(gta.config['data']['evfile'])
ft2fits = fits.open(gta.config['data']['scfile'])
TSTART = float(ft1fits['EVENTS'].header["TSTART"]) - 30.
TSTOP = float(ft1fits['EVENTS'].header["TSTOP"]) + 30.
nevt = int(ft2fits['SC_DATA'].header['NAXIS2'])
src = gta.roi[gta.config['selection']['target']]
c0 = SkyCoord(ra = src.radec[0],dec = src.radec[1], unit = 'deg')
# the GTIs from the FT1 file
ft1_gti_start = ft1fits['GTI'].data.field('START')
ft1_gti_stop = ft1fits['GTI'].data.field('STOP')
# central times of GTI in SC file
tcen = 0.5 * (ft2fits['SC_DATA'].data.field("START") + \
ft2fits['SC_DATA'].data.field("STOP"))
mask = (tcen > TSTART) & (tcen < TSTOP)
# Spacecraft coordinates
cz = SkyCoord(ra = ft2fits['SC_DATA'].data.field('RA_SCZ'),
dec = ft2fits['SC_DATA'].data.field('DEC_SCZ'),
unit = 'deg')
cx = SkyCoord(ra = ft2fits['SC_DATA'].data.field('RA_SCX'),
dec = ft2fits['SC_DATA'].data.field('DEC_SCX'),
unit = 'deg')
czen = SkyCoord(ra = ft2fits['SC_DATA'].data.field('RA_ZENITH'),
dec = ft2fits['SC_DATA'].data.field('DEC_ZENITH'),
unit = 'deg')
sep_z0 = c0.separation(cz)
sep_zenith0 = c0.separation(czen)
id = np.cos(np.radians(sep_z0))
# compute phi direction to src in SC coordinates
phi = get_phi(cz = cz, cx = cx, c0 = c0)
# livetime
livetime = ft2fits['SC_DATA'].data.field('LIVETIME')
# loop over GTIs in SC file
af, ab = np.zeros(nevt), np.zeros(nevt)
logging.info("Calculating exposure for E = {0:.2f} MeV".format(energy))
mask = mask & (sep_zenith0.value <= gta.config['selection']['zmax'])
ft1_gti_bins = np.array([ft1_gti_start, ft1_gti_stop])
igti = np.digitize(tcen, ft1_gti_start)
# make 1d array with start0,stop0,start1,stop0,...
ft1_gti_bins = ft1_gti_bins.T.reshape(-1)
# check for all times of GTI file in which bin they are.
# if even, then inside a GTI if odd then outside
#igti = np.digitize(tcen, ft1_gti_bins)
#mask = (igti > 0) & (igti < len(ft1_gti_bins)) & \
#mask & np.invert((igti - 1 % 2).astype(np.bool))
t1 = time.time()
for i in range(nevt):
if not mask[i]: continue
if tcen[i] > ft1_gti_start[igti[i] - 1] and tcen[i] < ft1_gti_stop[igti[i] - 1]:
af[i] = aeff_fa.value(energy,
float(sep_z0[i].value),
float(phi[i])) *livetime[i]
ab[i] = aeff_ba.value(energy,
float(sep_z0[i].value),
float(phi[i])) *livetime[i]
print ("it took {0:.2f}s".format(time.time() - t1))
logging.info("Done")
return tcen,af,ab
def EdispPlot(IRFs,
perc,
ptype,
pmin,
pmax,
value,
nbins,
front=True,
back=False,
plot=True):
#check ptype input value
if ptype not in ['energy', 'theta']:
print 'Error, ptype input must be either "energy" or "costheta".'
return None
#make bins accordingly
if ptype == 'energy':
bins = log10_array(nbins + 1, pmin, pmax)
cents = [
10**((log10(e) + log10(E)) / 2.)
for e, E in zip(bins[:-1], bins[1:])
]
else:
bins = array([
float(pmin + i * (pmax - pmin) / float(nbins))
for i in range(nbins + 1)
])
cents = [(c + C) / 2. for c, C in zip(bins[:-1], bins[1:])]
#access the available IRFs
pyIrfLoader.Loader_go()
if front and back:
#get front and back IRFs, get the energy resolution for both, then average them
print "oops, can't do FRONT and BACK right now, sorry, try again"
return None
#conv='FRONT + BACK'
#irfs_front=pyIrfLoader.IrfsFactory.instance().create(IRFs+"::FRONT")
#irfs_back=pyIrfLoader.IrfsFactory.instance().create(IRFs+"::BACK")
##get for either one theta and range of energies or vice versa
#if ptype=='energy':
#res_front=[energyRes(irfs_front.edisp(),perc,e,value) for e in cents]
#res_back=[energyRes(irfs_back.edisp(),perc,e,value) for e in cents]
#res=[(f+b)/2. for f,b in zip(res_front,res_back)]
#else:
#res_front=[energyRes(irfs_front.edisp(),perc,value,th) for th in cents]
#res_back=[energyRes(irfs_back.edisp(),perc,value,th) for th in cents]
#res=[(f+b)/2. for f,b in zip(res_front,res_back)]
else:
#get the appropriate IRFs, get energy resolution based on ptype
conv = ('FRONT' if front else "BACK")
irfs = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::" + conv)
if ptype == 'energy':
res = [energyRes(irfs.edisp(), perc, e, value) for e in cents]
else:
res = [energyRes(irfs.edisp(), perc, value, th) for th in cents]
#make histogram and fill
edhist = TH1F('edhist', '', nbins, bins)
for i, e in enumerate(res):
edhist.SetBinContent(i + 1, e)
#set axis titles and do other style stuff
edhist.GetXaxis().CenterTitle()
edhist.GetYaxis().CenterTitle()
xtitle = ('Energy (MeV)' if ptype == 'energy' else '#theta (#circ)')
ytitle = ('#frac{#Delta E}{E} (%.1f' % (perc * 100) + '%' +
' containtment for #theta = %.1f^{#circ} )' % value
if ptype == 'energy' else '#frac{#Delta E}{E} (%.1f' %
(perc * 100) + '%' + 'containment for E = %.1f MeV)' % value)
edhist.SetYTitle(ytitle)
edhist.SetLineColor(1)
edhist.SetMarkerColor(1)
edhist.SetMarkerStyle(20)
if plot:
can = TCanvas(
'can', '%s %s %.1f' % (IRFs, conv, perc * 100) +
'% Energy Resolution' + ' vs. %s' % ptype, 1000, 800)
can.SetTicks(1, 1)
if ptype == 'energy':
can.SetLogx(1)
edhist.Draw('pl')
SetOwnership(can, False)
SetOwnership(edhist, False)
return edhist
def AeffPlot2D(IRFs,
nebins=64,
nctbins=32,
emin=1.e2,
emax=1.e5,
ctmin=0.2,
ctmax=1.0,
front=True,
back=False,
plot=True,
color=True):
#should probably put some reasonability test on min and max values...
ebins = log10_array(nebins + 1, emin, emax)
#get the logarithmic midpoints for energy bins
ecents = [
10**((log10(e) + log10(E)) / 2.)
for e, E in zip(ebins[:-1], ebins[1:])
]
ctbins = [
ctmin + i * (ctmax - ctmin) / nctbins for i in range(nctbins + 1)
]
#get theta values in degrees of centers of cos(theta) bins
thetas = [
r2d * arccos((c + C) / 2.) for c, C in zip(ctbins[:-1], ctbins[1:])
]
#get the available IRFs
pyIrfLoader.Loader_go()
if front and back:
conv = 'FRONT + BACK'
#get front and back IRFs
irfs_front = pyIrfLoader.IrfsFactory.instance().create(IRFs +
"::FRONT")
irfs_back = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::BACK")
#get effective area for both sections and then add
Aeff_front = getAeff_nophi(irfs_front.aeff(), ecents, thetas)
Aeff_back = getAeff_nophi(irfs_back.aeff(), ecents, thetas)
Aeff = Aeff_front + Aeff_back
else:
#get irfs for proper section and get effective area
conv = ('FRONT' if front else 'BACK')
irfs = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::" + conv)
Aeff = getAeff_nophi(irfs.aeff(), ecents, thetas)
#make and fill hist with some style options
aehist = TH2F('aehist', '', nebins, array(ebins), nctbins, array(ctbins))
for c in range(nctbins):
for e in range(nebins):
aehist.SetBinContent(e + 1, c + 1, Aeff[e][c])
aehist.GetXaxis().CenterTitle()
aehist.GetYaxis().CenterTitle()
aehist.SetXTitle('Energy (MeV)')
aehist.SetYTitle('cos(#theta)')
aehist.SetContour(99)
if plot:
#if plotting, take care of some formatting issues
if color:
BPalette()
else:
GPalette()
aeffcan = TCanvas('aeffcan', '%s %s Effective Area' % (IRFs, conv),
1000, 800)
aeffcan.SetTicks(1, 1)
aeffcan.SetLogx(1)
aeffcan.SetFrameFillColor(1)
aeffcan.SetFrameFillStyle(1001)
aehist.GetXaxis().SetAxisColor(0)
aehist.GetYaxis().SetAxisColor(0)
aehist.Draw('cont4z')
SetOwnership(aeffcan, False)
SetOwnership(aehist, False)
#return the 2D hist
return aehist
def PSFPlot(IRFs,
perc,
ptype,
pmin,
pmax,
value,
nbins,
perc2=None,
front=True,
back=False,
plot=True):
#check choice of ptype
if ptype not in ['energy', 'theta']:
print 'Error, ptype input must be either "energy" or "theta".'
return None
#make bins accordingly
if ptype == 'energy':
bins = log10_array(nbins + 1, pmin, pmax)
cents = [
10**((log10(e) + log10(E)) / 2.)
for e, E in zip(bins[:-1], bins[1:])
]
else:
bins = [pmin + i * (pmax - pmin) / nctbins for i in range(nbins + 1)]
cents = [(c + C) / 2. for c, C in zip(bins[:-1], bins[1:])]
#access the available IRFs
pyIrfLoader.Loader_go()
if front and back:
print "Calculating containment ratios for FRONT+BACK as the average"
print "this is approximately correct near 685", "containment but underestimates for larger containment percentages"
#get front and back IRFs
conv = 'FRONT + BACK'
irfs_front = pyIrfLoader.IrfsFactory.instance().create(IRFs +
"::FRONT")
irfs_back = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::BACK")
#get the front and back containment angles, either for one theta and range of energies or vice versa
#then average the 2, makes the assumption that we'll have about the same number of events in both sections
if ptype == 'energy':
cont_front = [
psfContAng(irfs_front.psf(), perc, e, value) for e in cents
]
cont_back = [
psfContAng(irfs_back.psf(), perc, e, value) for e in cents
]
cont = array([(f + b) / 2. for f, b in zip(cont_front, cont_back)])
#if we have a value for perc2, calculate those containment angles
#average these values for front and back before calculating the ratio
if perc2 != None:
cont2_front = array([
psfContAng(irfs_front.psf(), perc2, e, value)
for e in cents
])
cont2_back = array([
psfContAng(irfs_back.psf(), perc2, e, value) for e in cents
])
cont2 = [(f + b) / 2. for f, b in zip(cont2_front, cont2_back)]
cont = array([c / C for c, C in zip(cont2, cont)])
else:
cont_front = [
psfContAng(irfs_front.psf(), perc, value, th) for th in cents
]
cont_back = [
psfContAng(irfs_back.psf(), perc, value, th) for th in cents
]
cont = array([(f + b) / 2. for f, b in zip(cont_front, cont_back)])
if perc2 != None:
cont2_front = [
psfContAng(irfs_front.psf(), perc2, value, th)
for th in cents
]
cont2_back = [
psfContAng(irfs_back.psf(), perc2, value, th)
for th in cents
]
cont2 = [(f + b) / 2. for f, b in zip(cont2_front, cont2_back)]
cont = array([c / C for c, C in zip(cont2, cont)])
else:
#get appropriate IRFs
conv = ('FRONT' if front else "BACK")
irfs = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::" + conv)
#get containtment angles
if ptype == 'energy':
cont = array(
[psfContAng(irfs.psf(), perc, e, value) for e in cents])
if perc2 != None:
#if we actually have a value for perc2, get second set of containment angles then calculate ratio
cont2 = [
psfContAng(irfs.psf(), perc2, e, value) for e in cents
]
cont = array([c / C for c, C in zip(cont2, cont)])
else:
cont = array(
[psfContAng(irfs.psf(), perc, value, th) for th in cents])
if perc2 != None:
cont2 = [
psfContAng(irfs.psf(), perc2, value, th) for th in cents
]
cont = array([c / C for c, C in zip(cont2, cont)])
#make the histogram and fill
psfhist = TH1F('psfhist', '', nbins, bins)
for i, c in enumerate(cont):
psfhist.SetBinContent(i + 1, c)
#set axis titles and do other style stuff
psfhist.GetXaxis().CenterTitle()
psfhist.GetYaxis().CenterTitle()
xtitle = ('Energy (MeV)' if ptype == 'energy' else '#theta (#circ)')
psfhist.SetXTitle(xtitle)
ytitle = ('%.1f' % (perc * 100) +
'% Containment Angle (#circ)' if perc2 == None else '%.1f' %
(perc2 * 100) + '%' + '/%.1f' % (perc * 100) + '%' +
'Containment Angle Ratio')
psfhist.SetYTitle(ytitle)
psfhist.SetLineColor(1)
psfhist.SetMarkerColor(1)
psfhist.SetMarkerStyle(20)
if plot:
if perc2 == None:
can = TCanvas(
'can', '%s %s %.1f' % (IRFs, conv, perc * 100) +
'% Containment Angle' + ' vs. %s' % ptype, 1000, 800)
can.SetLogy(1)
else:
can = TCanvas(
'can',
'%s %s %.1f' % (IRFs, conv, perc2 * 100) + '%' + '/%.1f' %
(perc * 100) + '% Containment Angle Ratio' + ' vs. %s' % ptype,
1000, 800)
can.SetTicks(1, 1)
if ptype == 'energy':
can.SetLogx(1)
psfhist.Draw('pl')
SetOwnership(can, False)
SetOwnership(psfhist, False)
return psfhist
def AeffPlot1D(IRFs,
nbins,
ptype,
pmin,
pmax,
value,
front=True,
back=False,
plot=True):
#check pytpe input
if ptype not in ['energy', 'theta']:
print 'Error, ptype input must be either "energy" or "theta".'
return None
#bin accordingly depending on choice
if ptype == 'energy':
bins = log10_array(nbins + 1, pmin, pmax)
cents = [
10**((log10(e) + log10(E)) / 2.)
for e, E in zip(bins[:-1], bins[1:])
]
else:
bins = [
float(pmin + i * (pmax - pmin) / float(nbins))
for i in range(nbins + 1)
]
cents = [(c + C) / 2. for c, C in zip(bins[:-1], bins[1:])]
#access the available IRFS
pyIrfLoader.Loader_go()
if front and back:
#get FRONT and BACK IRFs
conv = 'FRONT + BACK'
irfs_front = pyIrfLoader.IrfsFactory.instance().create(IRFs +
"::FRONT")
irfs_back = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::BACK")
#get effective area in bins, either at one theta or at one energy
if ptype == 'energy':
Aeff_front = getAeff_nophi(irfs_front.aeff(), cents, [value])
Aeff_back = getAeff_nophi(irfs_back.aeff(), cents, [value])
else:
Aeff_front = getAeff_nophi(irfs_front.aeff(), [value], cents)
Aeff_back = getAeff_nophi(irfs_back.aeff(), [value], cents)
#add effective areas
Aeff = Aeff_front + Aeff_back
else:
#get appropriate IRFs
conv = ('FRONT' if front else "BACK")
irfs = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::" + conv)
#get effective area for either one theta or one energy
if ptype == 'energy':
Aeff = getAeff_nophi(irfs.aeff(), cents, [value])
else:
Aeff = getAeff_nophi(irfs.aeff(), [value], cents)
#make histogram and fill
aehist = TH1F('aehist', '', nbins, array(bins))
for i, a in enumerate(Aeff):
aehist.SetBinContent(i + 1, a)
#set axis titles and do other style stuff
aehist.GetXaxis().CenterTitle()
aehist.GetYaxis().CenterTitle()
xtitle = ('Energy (MeV)' if ptype == 'energy' else '#theta (#circ)')
aehist.SetXTitle(xtitle)
aehist.SetYTitle('A_{eff} (m^{2} )')
aehist.SetLineColor(1)
aehist.SetMarkerColor(1)
aehist.SetMarkerStyle(20)
if plot:
can = TCanvas('can',
'%s %s Effective Area vs. %s' % (IRFs, conv, ptype),
1000, 800)
can.SetTicks(1, 1)
if ptype == 'energy':
can.SetLogx(1)
aehist.Draw('pl')
SetOwnership(can, False)
SetOwnership(aehist, False)
return aehist
