def __init__(self, name='delta2dint'):
# Gauss source parameters
self.xpos = Parameter(name, 'xpos', 0) # p[0]
self.ypos = Parameter(name, 'ypos', 0) # p[1]
self.ampl = Parameter(name, 'ampl', 1) # p[2]
self.shape = sau.get_data().shape
ArithmeticModel.__init__(self, name, (self.xpos, self.ypos, self.ampl))
def from_gammacat(cls, source):
d = source.data
glon = Parameter(name='GLON', value=d['glon'].value, unit=d['glon'].unit)
glat = Parameter(name='GLAT', value=d['glat'].value, unit=d['glat'].unit)
parameters = [glon, glat]
return cls(parameters=parameters)
def __init__(self, name='normal'):
self.sigma = Parameter(name, 'sigma', 1., alwaysfrozen=True)
self.x0 = Parameter(name, 'x0', 1., alwaysfrozen=True)
self.norm = Parameter(name, 'norm', 1., alwaysfrozen=True)
ArithmeticModel.__init__(self, name, (self.sigma, self.x0, self.norm))
def __init__(self, name='disk2d'):
self.xpos = Parameter(name, 'xpos', 0) # p[0]
self.ypos = Parameter(name, 'ypos', 0) # p[1]
self.ampl = Parameter(name, 'ampl', 1) # p[2]
self.r0 = Parameter(name, 'r0', 1, 0) # p[3]
ArithmeticModel.__init__(self, name,
(self.xpos, self.ypos, self.ampl, self.r0))
def __init__(self, name='mygauss'):
self.sigma = Parameter(name, 'sigma', 10, min=0, max=10)
self.pos = Parameter(name, 'pos', 0, min=-10, max=10)
self.ampl = Parameter(name, 'ampl', 5)
self.counter = 0
ArithmeticModel.__init__(self, name,
(self.sigma, self.pos, self.ampl))
def __init__(self, name='myplexpcutoff'):
self.Eo = Parameter(name, 'Eo', 1, frozen=True, units='keV') # p[0] Normalized at 1 TeV by default
self.beta = Parameter(name, 'beta', 1e-1, min=1e-3, max=10, units='1/TeV') # p[1]
self.gamma = Parameter(name, 'gamma', 2, min=-1, max=5) # p[2]
self.No = Parameter(name, 'No', 1e-11, min=1e-15, max=1e-5, units='1/cm^2/s/TeV') # p[3]
ArithmeticModel.__init__(self, name, (self.Eo, self.beta, self.gamma, self.No))
def __init__(self, name, kt_array=None):
if kt_array is None:
kt_array = DEFAULT_KT_ARRAY
else:
kt_array = np.atleast_1d(np.asfarray(kt_array))
self.gfac = Parameter(name, 'gfac', 0.5, 1e-4, 1e4, 1e-6, 1e6)
self.Abundanc = Parameter(name,
'Abundanc',
1.,
0.,
5.,
0.0,
hugeval,
frozen=True)
self.redshift = Parameter(name,
'redshift',
0.,
-0.999,
10.,
-0.999,
hugeval,
frozen=True)
self.norm = Parameter(name, 'norm', 1.0, 0.0, 1e24, 0.0, hugeval)
self._kt_array = kt_array
self._cur_cache_key = None
self._cached_vals = None
XSAdditiveModel.__init__(
self, name, (self.gfac, self.Abundanc, self.redshift, self.norm))
def __init__(self, name='normgauss2dint'):
# Gauss source parameters
self.xpos = Parameter(name, 'xpos', 0) # p[0]
self.ypos = Parameter(name, 'ypos', 0) # p[1]
self.ampl = Parameter(name, 'ampl', 1) # p[2]
self.fwhm = Parameter(name, 'fwhm', 1) # p[3]
ArithmeticModel.__init__(self, name,
(self.xpos, self.ypos, self.ampl, self.fwhm))
def __init__(self, name='shell2d'):
self.xpos = Parameter(name, 'xpos', 0) # p[0]
self.ypos = Parameter(name, 'ypos', 0) # p[1]
self.ampl = Parameter(name, 'ampl', 1) # p[2]
self.r0 = Parameter(name, 'r0', 1, 0) # p[3]
self.width = Parameter(name, 'width', 0.1, 0)
ArithmeticModel.__init__(
self, name, (self.xpos, self.ypos, self.ampl, self.r0, self.width))
def __init__(self, name='normdisk2d'):
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ampl = Parameter(name, 'ampl',
1) # misnomer ... this is really the integral
self.r0 = Parameter(name, 'r0', 1, 0)
ArithmeticModel.__init__(self, name,
(self.xpos, self.ypos, self.ampl, self.r0))
def __init__(self, name='ecpl'):
self.gamma = Parameter(name, 'gamma', 2, min=-10, max=10)
self.ref = Parameter(name, 'ref', 1, frozen=True)
self.ampl = Parameter(name, 'ampl', 1, min=0)
self.cutoff = Parameter(name, 'cutoff', 1, min=0, units='1/TeV')
ArithmeticModel.__init__(self, name, (self.gamma, self.ref, self.ampl,
self.cutoff))
self._use_caching = True
self.cache = 10
def from_gammacat(cls, source):
d = source.data
glon = Parameter(name='GLON', value=d['glon'].value, unit=d['glon'].unit)
glat = Parameter(name='GLAT', value=d['glat'].value, unit=d['glat'].unit)
radius = Parameter(name='Radius', value=d['morph_sigma'].value, unit=d['morph_sigma'].unit)
width = Parameter(name='Width', value=0, unit='deg')
parameters = [glon, glat, radius, width]
return cls(parameters=parameters)
def __init__(self, name='hesssource2d'):
# Gauss source parameters
self.xpos = Parameter(name, 'xpos', 0) # p[0]
self.ypos = Parameter(name, 'ypos', 0) # p[1]
self.ampl = Parameter(name, 'ampl', 1) # p[2]
self.fwhm = Parameter(name, 'fwhm', 1) # p[3]
self.loadpsf('psf.json')
ArithmeticModel.__init__(self, name,
(self.xpos, self.ypos, self.ampl, self.fwhm))
def from_gammacat(cls, source):
d = source.data
glon = Parameter(name='GLON', value=d['glon'].value, unit=d['glon'].unit)
glat = Parameter(name='GLAT', value=d['glat'].value, unit=d['glat'].unit)
sigma = Parameter(name='Sigma', value=d['morph_sigma'].value, unit=d['morph_sigma'].unit)
# TODO: fill `morph_sigma2` and `morph_pa` info
parameters = [glon, glat, sigma]
return cls(parameters=parameters)
def from_plist(cls, plist):
par = plist['amplitude']
prefactor = Parameter(name='Prefactor', value=par.value, unit=par.unit)
par = plist['index']
index = Parameter(name='Index', value=-par.value, unit=par.unit)
par = plist['reference']
scale = Parameter(name='Scale', value=par.value, unit=par.unit)
parameters = [prefactor, index, scale]
return cls(parameters=parameters)
def __init__(self, name='zbabs'):
self.nH = Parameter(name, 'nH', 1.e-4, 0.0, 1.0e5, 0.0, 1.0e6,
'10^22 atoms / cm^2')
self.nHeI = Parameter(name, 'nHeI', 1.e-5, 0.0, 1.0e5, 0.0, 1.0e6,
'10^22 atoms / cm^2')
self.nHeII = Parameter(name, 'nHeII', 1.e-6, 0.0, 1.0e5, 0.0,
1.0e6, '10^22 atoms / cm^2')
self.redshift = Parameter(name, 'redshift', 0.0, 0.0, 1.0e5, 0.0,
1.0e6)
XSMultiplicativeModel.__init__(
self, name, (self.nH, self.nHeI, self.nHeII, self.redshift))
def from_plist(cls, plist):
par = plist['amplitude']
integral = Parameter(name='Integral', value=par.value, unit=par.unit)
par = plist['index']
index = Parameter(name='Index', value=-par.value, unit=par.unit)
par = plist['emin']
lower_limit = Parameter(name='LowerLimit', value=par.value, unit=par.unit)
par = plist['emax']
upper_limit = Parameter(name='UpperLimit', value=par.value, unit=par.unit)
parameters = [integral, index, lower_limit, upper_limit]
return cls(parameters=parameters)
def __init__(self, name='normgauss2dint'):
# Gauss source parameters
self.wcs = WCS.WCS()
self.coordsys = "galactic" # default
self.binsize = 1.0
self.xpos = Parameter(name, 'xpos', 0) # p[0]
self.ypos = Parameter(name, 'ypos', 0) # p[1]
self.ampl = Parameter(name, 'ampl', 1) # p[2]
self.fwhm = Parameter(name, 'fwhm', 1, min=0) # p[3]
self.shape = None
self.n_ebins = None
ArithmeticModel.__init__(self, name,
(self.xpos, self.ypos, self.ampl, self.fwhm))
def to_sherpa(self, modelname='Default'):
"""Convert to sherpa parameter"""
from sherpa.models import Parameter
par = Parameter(modelname=modelname, name=self.name,
val=self.value, units=self.unit,
min=self.parmin, max=self.parmax,
frozen=self.frozen)
return par
def __init__(self, wcs, name='UniformGaussianPlane'):
""" Default initialization
"""
self.__name__ = name
self.wcs = pywcs.WCS()
self.binsize = 1.0
self.coordsys = "galactic" # default
#self.ampl = Parameter(name,'ampl',1.0,0.0,1e6)
#self.thick = Parameter(name,'thick',0.4,0.,1.0)
#self.ypos = Parameter(name,'ypos',0.0,-1.5,1.5)
"""
self.ampl = Parameter(name,'ampl',1.0,0.0,1e6)
self.thick = Parameter(name,'thick',15,0.,50)
self.ypos = Parameter(name,'ypos',200,125,275)
"""
#import IPython; IPython.embed()
self.binsize_deg = np.abs(wcs.wcs.cdelt[0])
res = wcs.wcs_world2pix(np.array([0., 0], ndmin=2), 1)
xpix, ypix = res[0]
#self.binsize_deg=0.02
#ypix=202.81000059
self.ampl = Parameter(name, 'ampl', 1.0, 0.0, 1e6)
self.thick = Parameter(name, 'thick', 0.3 / self.binsize_deg, 0.,
1 / self.binsize_deg)
self.ypos = Parameter(name, 'ypos', ypix,
ypix - (1.5 / self.binsize_deg),
ypix + (1.5 / self.binsize_deg))
ArithmeticModel.__init__(self, name,
(self.ypos, self.thick, self.ampl))
class UniformGaussianPlane(ArithmeticModel):
""" Uniform Gaussian band model
"""
def __init__(self, wcs, name='UniformGaussianPlane'):
""" Default initialization
"""
self.__name__ = name
self.wcs = pywcs.WCS()
self.binsize = 1.0
self.coordsys = "galactic" # default
#self.ampl = Parameter(name,'ampl',1.0,0.0,1e6)
#self.thick = Parameter(name,'thick',0.4,0.,1.0)
#self.ypos = Parameter(name,'ypos',0.0,-1.5,1.5)
"""
self.ampl = Parameter(name,'ampl',1.0,0.0,1e6)
self.thick = Parameter(name,'thick',15,0.,50)
self.ypos = Parameter(name,'ypos',200,125,275)
"""
#import IPython; IPython.embed()
self.binsize_deg = np.abs(wcs.wcs.cdelt[0])
res = wcs.wcs_world2pix(np.array([0., 0], ndmin=2), 1)
xpix, ypix = res[0]
#self.binsize_deg=0.02
#ypix=202.81000059
self.ampl = Parameter(name, 'ampl', 1.0, 0.0, 1e6)
self.thick = Parameter(name, 'thick', 0.3 / self.binsize_deg, 0.,
1 / self.binsize_deg)
self.ypos = Parameter(name, 'ypos', ypix,
ypix - (1.5 / self.binsize_deg),
ypix + (1.5 / self.binsize_deg))
ArithmeticModel.__init__(self, name,
(self.ypos, self.thick, self.ampl))
def set_parameters(self, ypos, thick, ampl, err_ypos=0.2, thick_max=1.5):
""" Define source parameters
"""
self.thick.set(val=thick, min=0.0, max=thick_max)
self.ypos.set(val=ypos, min=-err_ypos, max=err_ypos)
self.ampl.set(val=ampl)
def set_wcs(self, wcs):
self.wcs = wcs
# We assume bins have the same size along x and y axis
self.binsize = np.abs(self.wcs.wcs.cdelt[0])
if self.wcs.wcs.ctype[0][0:4] == 'GLON':
self.coordsys = 'galactic'
elif self.wcs.wcs.ctype[0][0:2] == 'RA':
self.coordsys = 'fk5'
def calc(self, pars, x, y, *args, **kwargs):
(ypos, thick, ampl) = pars
res = self.wcs.wcs_world2pix(np.array([0., ypos], ndmin=2), 1)
xpix, ypix = res[0]
thr = thick / self.binsize
d2 = (y - ypix)**2
tsq = thr * thr
return ampl * np.exp(-0.5 * d2 / tsq)
def to_sherpa(self, modelname='Default'):
"""Convert to sherpa parameter"""
from sherpa.models import Parameter
min_ = np.finfo(np.float32).min if np.isnan(self.min) else self.min
max_ = np.finfo(np.float32).max if np.isnan(self.max) else self.max
return Parameter(
modelname=modelname,
name=self.name,
val=self.value,
units=self.unit,
min=min_,
max=max_,
frozen=self.frozen,
)
def __init__(self, name='psfmodel', kernel=None):
self._name = name
self._size = None
self._origin = None
self._center = None
self.radial = Parameter(name,
'radial',
0,
0,
1,
hard_min=0,
hard_max=1,
alwaysfrozen=True)
self.norm = Parameter(name,
'norm',
1,
0,
1,
hard_min=0,
hard_max=1,
alwaysfrozen=True)
self.kernel = kernel
self.model = None
Model.__init__(self, name)
def from_dict(cls, val):
pars = list()
for par in val['parameters']:
pars.append(
Parameter(name=par['name'],
value=float(par['value']),
unit=par['unit'],
parmin=float(par['min']),
parmax=float(par['max']),
frozen=par['frozen']))
try:
covariance = np.array(val['covariance'])
except KeyError:
covariance = None
return cls(parameters=pars, covariance=covariance)
def to_sherpa(self, modelname='Default'):
"""Convert to sherpa parameter"""
from sherpa.models import Parameter
parmin = np.finfo(np.float32).min if np.isnan(
self.parmin) else self.parmin
parmax = np.finfo(np.float32).max if np.isnan(
self.parmax) else self.parmax
par = Parameter(modelname=modelname,
name=self.name,
val=self.value,
units=self.unit,
min=parmin,
max=parmax,
frozen=self.frozen)
return par
def _astropy_to_sherpa_model(model):
"""
Converts the model using sherpa's usermodel suppling the parameter detail to sherpa
then using a decorator to allow the call method to act like the calc method
"""
def _calc2call(func):
"""This decorator makes call and calc work together."""
def _converter(inp, *x):
if func.n_inputs == 1:
retvals = func.evaluate(x[0], *inp)
else:
retvals = func.evaluate(x[0], x[1], *inp)
return retvals
return _converter
if len(model.ineqcons) > 0 or len(model.eqcons) > 0:
AstropyUserWarning('In/eqcons are not supported by sherpa these will be ignored!')
pars = []
linkedpars = []
for pname in model.param_names:
param = getattr(model, pname)
vals = [param.name, param.value, param.min, param.max, param.min,
param.max, None, param.fixed, False]
attrnames = ["name", "val", "min", "max", "hard_min", "hard_max",
"units", "frozen", "alwaysfrozen"]
if model.name is None:
model._name = ""
pars.append(Parameter(modelname="wrap_" + model.name, **dict([(atr, val) for atr, val in zip(attrnames, vals) if val is not None])))
if param.tied is not False:
linkedpars.append(pname)
smodel = UserModel(model.name, pars)
smodel.calc = _calc2call(model)
for pname in linkedpars:
param = getattr(model, pname)
sparam = getattr(smodel, pname)
sparam.link = param.tied(smodel)
return smodel
def __init__(self, statfunc=None, hyperpars={}, pars={}, name='prior'):
# Posterior hyper-parameters
self.hyperpars = []
for key in hyperpars.keys():
val = hyperpars[key]
param = Parameter(name, key, val, alwaysfrozen=True)
self.__dict__[key] = param
self.hyperpars.append(param)
# References to parameters in source model
self.pars = []
for key in pars.keys():
self.__dict__[key] = pars[key]
self.pars.append(pars[key])
self._statfuncset = False
self.statfunc = (lambda x: None)
if statfunc is not None:
self.statfunc = statfunc
self._statfuncset = True
Likelihood.__init__(self, name)
def __init__(self, name='proton'):
# First precompute some quantities
self.Ep_min = 1e-1 # TeV
self.Ep_max = 1e5 # TeV
self.nbins = 300
self.lEp_min = np.log10(self.Ep_min)
self.lEp_max = np.log10(self.Ep_max)
self.Ep = np.logspace(self.lEp_min, self.lEp_max, self.nbins)
self.lbsize = (self.lEp_max - self.Ep_min) / self.nbins
self.Fgam = None
self.EG = None
self.EP = None
self.ncalc = 0
# Instantiate parameters
self.Eo = Parameter(name, 'Eo', 10, frozen=True, units='TeV') # p[0] Normalized at 10 TeV by default
self.beta = Parameter(name, 'beta', 1., min=1e-3, max=1e4, units='1/PeV') # p[1]
self.gamma = Parameter(name, 'gamma', 2.2, min=-1, max=5) # p[2]
self.ampl = Parameter(name, 'ampl', 1e-11, min=1e-15, max=1e15, units='1/cm^2/s/TeV') # p[3]
self.Einf = Parameter(name, 'Einf', 1, frozen=True, units='TeV') # p[4] 1 TeV by default
self.Esup = Parameter(name, 'Esup', 100, frozen=True, units='TeV') # p[5] 100 TeV by default
ArithmeticModel.__init__(self, name, (self.Eo, self.beta, self.gamma, self.ampl, self.Einf, self.Esup))
def from_list_of_dict_gammacat(cls, data):
return cls([Parameter.from_dict_gammacat(_) for _ in data])
def __init__(self, name='foo'):
self.kT = Parameter(name, 'kT', 1.0)
XSAdditiveModel.__init__(self, name, (self.kT))
def __init__(self, name='myexp'):
self.A = Parameter(name, 'A', 1)
self.mylambda = Parameter(name, 'mylambda', 2)
self.b = Parameter(name, 'b', 3)
self.counter = 0
ArithmeticModel.__init__(self, name, (self.A, self.mylambda, self.b))
def from_list_of_dict_xml(cls, data):
return cls([Parameter.from_dict_xml(_) for _ in data])
