def __init__(self, name='myexp'):
self.a = Parameter(name, 'a', 0)
self.b = Parameter(name, 'b', -1)
# The _exp instance is used to perform the model calculation,
# as shown in the calc method.
self._exp = Exp('hidden')
return ArithmeticModel.__init__(self, name, (self.a, self.b))
def __init__(self, name='DuleTelluric', same_b=False, same_d=False):
self.Cst_Cont = Parameter(name,
'Cst_Cont',
1.,
frozen=False,
min=0.95,
max=1.05)
self.t1_lam_0 = Parameter(name,
't1_lam_0',
5000.,
frozen=False,
min=0.0)
self.t1_b = Parameter(name, 't1_b', 3.5, frozen=False, min=1e-12)
self.t1_d = Parameter(name, 't1_d', 0.0005, frozen=False, min=0)
self.t1_tau_0 = Parameter(name, 't1_tau_0', 0.1, frozen=False, min=0.0)
self.t2_lam_0 = Parameter(name,
't2_lam_0',
5000.,
frozen=False,
min=0.0)
self.t2_b = Parameter(name, 't2_b', 3.5, frozen=False, min=1e-12)
self.t2_d = Parameter(name, 't2_d', 0.0005, frozen=False, min=0)
self.t2_tau_0 = Parameter(name, 't2_tau_0', 0.1, frozen=False, min=0.0)
self.resolution = 80000
if same_b: self.t1_b = self.t2_b
if same_d: self.t1_d = self.t2_d
ArithmeticModel.__init__(
self, name,
(self.Cst_Cont, self.t1_lam_0, self.t1_b, self.t1_d, self.t1_tau_0,
self.t2_lam_0, self.t2_b, self.t2_d, self.t2_tau_0))
def test_parameter_linked():
p = Parameter('foo', 'x1', 1.2)
q = Parameter('bar', 'x2', 2.2)
p.val = 2 + q
r = p._repr_html_()
assert r is not None
assert '<summary>Parameter</summary>' in r
assert '<table class="model">' in r
assert '<th class="model-odd">foo</th><td>x1</td><td>linked</td><td>4.2</td><td colspan="2">⇐ 2 + bar.x2</td><td></td></tr>' in r
def __init__(self, name='renamedpars'):
self.period = Parameter(name, 'period', 1, 1e-10, 10, tinyval)
self.offset = Parameter(name, 'offset', 0, 0, hard_min=0)
self.ampl = Parameter(name,
'ampl',
1,
1e-05,
hard_min=0,
aliases=['norm'])
ArithmeticModel.__init__(self, name,
(self.period, self.offset, self.ampl))
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 __init__(self, name='parametercase'):
self.period = Parameter(name, 'Period', 1, 1e-10, 10, tinyval)
self.offset = Parameter(name, 'Offset', 0, 0, hard_min=0)
self.ampl = Parameter(name, 'Ampl', 1, 1e-05, hard_min=0, aliases=["NORM"])
with warnings.catch_warnings(record=True) as warn:
warnings.simplefilter("always", DeprecationWarning)
pars = (self.perioD, self.oFFSEt, self.NORM)
validate_warning(warn)
self._basemodel = Sin()
ArithmeticModel.__init__(self, name, pars)
def __init__(self, name='bbody'):
self.space = Parameter(name,
'space',
0,
0,
1,
0,
1,
'0 - energy | 1 - wave',
alwaysfrozen=True)
self.kT = Parameter(name, 'kT', 1, 0.1, 1000, 0, 1e+10, 'keV')
self.ampl = Parameter(name, 'ampl', 1, 1e-20, 1e+20, 1e-20, 1e+20)
ArithmeticModel.__init__(self, name, (self.space, self.kT, self.ampl))
def __init__(self, name='polynomial'):
pars = []
for i in xrange(6):
pars.append(Parameter(name, 'c%d' % i, 0, frozen=True))
pars[0].val = 1
pars[0].frozen = False
for p in pars:
setattr(self, p.name, p)
self.offset = Parameter(name, 'offset', 0, frozen=True)
pars.append(self.offset)
ArithmeticModel.__init__(self, name, pars)
def __init__(self, name='thetestmodel'):
self.notseen = Parameter(name,
'notseen',
10,
min=5,
max=15,
hidden=True)
self.p1 = Parameter(name, 'P1', 1, min=0, max=10)
self.accent = Parameter(name, 'accent', 2, min=0, max=10, frozen=True)
self.norm = Parameter(name, 'norm', 100, min=0, max=1e4)
ArithmeticModel.__init__(
self, name, (self.notseen, self.p1, self.accent, self.norm))
def __init__(self, name='absorptionedge'):
self.edgew = Parameter(name,
'edgew',
5000.,
tinyval,
frozen=True,
units='angstroms')
self.tau = Parameter(name, 'tau', 0.5)
self.index = Parameter(name,
'index',
3.0,
alwaysfrozen=True,
hidden=True)
ArithmeticModel.__init__(self, name,
(self.edgew, self.tau, self.index))
def __init__(self, name='thcompc'):
self.gamma_tau = Parameter(name, 'gamma_tau', 1.7, 1.001, 5, 1.001,
10)
self.kT_e = Parameter(name,
'kT_e',
50,
0.5,
150,
0.5,
150,
units='keV')
self.z = Parameter(name, 'z', 0.0, 0, 5, 0, 5, frozen=True)
pars = (self.gamma_tau, self.kT_e, self.z)
XSConvolutionKernel.__init__(self, name, pars)
def __init__(self, name='logabsorption'):
self.fwhm = Parameter(name,
'fwhm',
100.,
tinyval,
hard_min=tinyval,
units="km/s")
self.pos = Parameter(name,
'pos',
5000.,
tinyval,
frozen=True,
units='angstroms')
self.tau = Parameter(name, 'tau', 0.5)
ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.tau))
def __init__(self, name='zkerrbb'):
self.eta = Parameter(name, 'eta', 0, 0, 1.0, 0, 1.0, frozen=True)
self.a = Parameter(name, 'a', 0.5, -0.99, 0.999, -0.99, 0.9999)
self.i = Parameter(name,
'i',
30,
0,
85,
0,
85,
units='degree',
frozen=True)
self.Mbh = Parameter(name,
'Mbh',
1e7,
3,
1e10,
3,
1e10,
units='M_sun',
frozen=True)
self.Mdd = Parameter(name,
'Mdd',
1,
1e-5,
1e4,
1e-5,
1e5,
units='M0yr')
self.z = Parameter(name, 'z', 0.01, 0, 10, 0, 10, frozen=True)
self.fcol = Parameter(name,
'fcol',
2,
-100,
100,
-100,
100,
frozen=True)
self.rflag = Parameter(name, 'rflag', 1, alwaysfrozen=True)
self.lflag = Parameter(name, 'lflag', 1, alwaysfrozen=True)
self.norm = Parameter(name, 'norm', 1.0, 0, 1e24, 0, hugeval)
pars = (self.eta, self.a, self.i, self.Mbh, self.Mdd, self.z,
self.fcol, self.rflag, self.lflag, self.norm)
XSAdditiveModel.__init__(self, name, pars)
def __init__(self, modelname):
self.LineE = Parameter(modelname=modelname,
name='LineE',
val=1,
min=0,
max=1e38)
self.Sigma = Parameter(modelname=modelname,
name='Sigma',
val=1,
min=0,
max=1e38)
self.norm = Parameter(modelname=modelname,
name='norm',
val=1,
min=0,
max=1e38)
pars = (self.LineE, self.Sigma, self.norm)
super(ArithmeticModel, self).__init__(modelname, pars=pars)
def test_parameter():
p = Parameter('foo', 'x1', 1.2)
r = p._repr_html_()
assert r is not None
assert '<summary>Parameter</summary>' in r
assert '<table class="model">' in r
assert '<tr><th class="model-odd">foo</th><td>x1</td><td><input disabled type="checkbox" checked></input></td><td>1.2</td><td>-MAX</td><td>MAX</td><td></td></tr>' in r
def __init__(self, name='accretiondisk'):
self.ref = Parameter(name,
'ref',
5000.,
frozen=True,
units='angstroms')
self.beta = Parameter(name, 'beta', 0.5, -10, 10)
self.ampl = Parameter(name, 'ampl', 1.)
self.norm = Parameter(name,
'norm',
20000.0,
tinyval,
alwaysfrozen=True,
hidden=True)
ArithmeticModel.__init__(self, name,
(self.ref, self.beta, self.ampl, self.norm))
def __init__(self, name='absorptionlorentz'):
self.fwhm = Parameter(name,
'fwhm',
100.,
tinyval,
hard_min=tinyval,
units="km/s")
self.pos = Parameter(name,
'pos',
5000.,
tinyval,
frozen=True,
units='angstroms')
self.ewidth = Parameter(name, 'ewidth', 1.)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.pos, self.ewidth))
def __init__(self, name='powerlaw'):
self.refer = Parameter(name,
'refer',
5000.,
tinyval,
hard_min=tinyval,
frozen=True,
units="angstroms")
self.ampl = Parameter(name,
'ampl',
1.,
tinyval,
hard_min=tinyval,
units="angstroms")
self.index = Parameter(name, 'index', -0.5, -10.0, 10.0)
ArithmeticModel.__init__(self, name,
(self.refer, self.ampl, self.index))
def __init__(self, name='emissionlorentz'):
self.fwhm = Parameter(name,
'fwhm',
100.,
tinyval,
hard_min=tinyval,
units="km/s")
self.pos = Parameter(name,
'pos',
5000.,
tinyval,
frozen=True,
units='angstroms')
self.flux = Parameter(name, 'flux', 1.)
self.kurt = Parameter(name, 'kurt', 2., frozen=True)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.pos, self.flux, self.kurt))
def init(self, modelname, x, data, parameters):
#print 'BinReaderModel(%s)' % modelname
self.data = data
pars = []
#print ' copying parameters'
for param, nbins in parameters:
lo = param.min
hi = param.max
newp = Parameter(modelname=modelname,
name=param.name,
val=param.val,
min=lo,
max=hi,
hard_min=lo,
hard_max=hi)
setattr(self, param.name, newp)
pars.append(newp)
#print ' adding norm'
newp = Parameter(modelname=modelname,
name='norm',
val=1,
min=0,
max=1e10,
hard_min=-1e300,
hard_max=1e300)
self.norm = newp
pars.append(newp)
#print ' adding redshift'
newp = Parameter(modelname=modelname,
name='redshift',
val=0,
min=0,
max=10,
hard_min=0,
hard_max=100)
self.redshift = newp
pars.append(newp)
self.x = x
self.binnings = [(param.min, param.max, nbins)
for param, nbins in parameters]
super(RebinnedModel, self).__init__(modelname, pars=pars)
def test_link_manual(attr):
"""Check out parameter linking. Use .val or .link"""
p = Parameter('model', 'eta', 2)
q = Parameter('other', 'bob', 3)
assert p.link is None
assert q.link is None
assert p.val == 2
assert q.val == 3
setattr(p, attr, 2 * q)
assert p.val == 6
assert q.link is None
assert isinstance(p.link, BinaryOpParameter)
assert isinstance(p.link.parts[0], ConstantParameter)
assert p.link.parts[0].val == 2
assert isinstance(p.link.parts[1], Parameter)
assert p.link.parts[1] is q
def __init__(self, name='lorentz2d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ellip = Parameter(name,
'ellip',
0,
0,
0.999,
0,
0.9999,
frozen=True)
self.theta = Parameter(name,
'theta',
0,
-2 * numpy.pi,
2 * numpy.pi,
-2 * numpy.pi,
4 * numpy.pi,
'radians',
frozen=True)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.xpos, self.ypos, self.ellip,
self.theta, self.ampl))
self.cache = 0
def __init__(self, name='fm'):
self.ebv = Parameter(name, 'ebv', 0.5) # E(B-V)
self.x0 = Parameter(name, 'x0', 4.6) # Position of Drude bump
self.width = Parameter(name, 'width', 0.06) # Width of Drude bump
self.c1 = Parameter(name, 'c1', 0.2)
self.c2 = Parameter(name, 'c2', 0.1)
self.c3 = Parameter(name, 'c3', 0.02)
self.c4 = Parameter(name, 'c4', 0.1)
ArithmeticModel.__init__(self, name,
(self.ebv, self.x0, self.width, self.c1,
self.c2, self.c3, self.c4))
def __init__(self, name='seaton'):
self.ebv = Parameter(name, 'ebv', 0.5)
self._xtab = numpy.array([
0.0, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1,
2.2, 2.3, 2.4, 2.5, 2.6, 2.7
])
self._extab = numpy.array([
0.0, 1.36, 1.64, 1.84, 2.04, 2.24, 2.44, 2.66, 2.88, 3.14, 3.36,
3.56, 3.77, 3.96, 4.15, 4.26, 4.40, 4.52, 4.64
])
ArithmeticModel.__init__(self, name, (self.ebv, ))
def __init__(self, name='absorptiongaussian'):
self.fwhm = Parameter(name,
'fwhm',
100.,
tinyval,
hard_min=tinyval,
units="km/s")
self.pos = Parameter(name,
'pos',
5000.,
tinyval,
frozen=True,
units='angstroms')
self.ewidth = Parameter(name, 'ewidth', 1.)
self.limit = Parameter(name,
'limit',
4.,
alwaysfrozen=True,
hidden=True)
ArithmeticModel.__init__(
self, name, (self.fwhm, self.pos, self.ewidth, self.limit))
def __init__(self, name='opticalgaussian'):
self.fwhm = Parameter(name,
'fwhm',
100.,
tinyval,
hard_min=tinyval,
units="km/s")
self.pos = Parameter(name,
'pos',
5000.,
tinyval,
frozen=True,
units='angstroms')
self.tau = Parameter(name, 'tau', 0.5)
self.limit = Parameter(name,
'limit',
4.,
alwaysfrozen=True,
hidden=True)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.pos, self.tau, self.limit))
def __init__(self, name='bremsstrahlung'):
self.refer = Parameter(name,
'refer',
5000.,
tinyval,
hard_min=tinyval,
frozen=True,
units="angstroms")
self.ampl = Parameter(name,
'ampl',
1.,
tinyval,
hard_min=tinyval,
units="angstroms")
self.temperature = Parameter(name,
'temperature',
3000.,
tinyval,
hard_min=tinyval,
units="Kelvin")
ArithmeticModel.__init__(self, name,
(self.refer, self.ampl, self.temperature))
def __init__(self, name='sersic2d'):
self.r0 = Parameter(name, 'r0', 10, 0, hard_min=0)
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ellip = Parameter(name, 'ellip', 0, 0, 0.999, 0, 0.9999)
self.theta = Parameter(name, 'theta', 0, -2*numpy.pi, 2*numpy.pi, -2*numpy.pi,
4*numpy.pi, 'radians')
self.ampl = Parameter(name, 'ampl', 1)
self.n = Parameter(name,'n', 1, .1, 10, 0.01, 100, frozen=True )
ArithmeticModel.__init__(self, name,
(self.r0, self.xpos, self.ypos, self.ellip,
self.theta, self.ampl, self.n))
self.cache = 0
def __init__(self, name="voigtabsorptionline"):
# lambda' = lambda * (c + v')/(c + v) = lambda * k
self.k = Parameter(name, "k", 1.00005, frozen=False, min=1e-12)
self.lam_0 = Parameter(name, "lam_0", 5000.0, frozen=False, min=0.0)
self.b = Parameter(name, "b", 3.5, frozen=False, min=1e-12)
self.d = Parameter(name, "d", 0.0005, frozen=False, min=0)
self.N = Parameter(name, "N", 999, frozen=True, hidden=True, min=0.0)
self.f = Parameter(name, "f", 999, frozen=True, hidden=True, min=0.0)
self.tau_0 = Parameter(name, "tau_0", 0.1, frozen=False, min=0.0)
ArithmeticModel.__init__(
self, name,
(self.k, self.lam_0, self.b, self.d, self.N, self.f, self.tau_0))
def __init__(self, name='sm'):
self.ebv = Parameter(name, 'ebv', 0.5)
self._xtab = numpy.array([
0.00, 0.29, 0.45, 0.80, 1.11, 1.43, 1.82, 2.27, 2.50, 2.91, 3.65,
4.00, 4.17, 4.35, 4.57, 4.76, 5.00, 5.26, 5.56, 5.88, 6.25, 6.71,
7.18, 8.00, 8.50, 9.00, 9.50, 10.00
])
self._extab = numpy.array([
0.00, 0.16, 0.38, 0.87, 1.50, 2.32, 3.10, 4.10, 4.40, 4.90, 6.20,
7.29, 8.00, 8.87, 9.67, 9.33, 8.62, 8.00, 7.75, 7.87, 8.12, 8.15,
8.49, 9.65, 10.55, 11.55, 12.90, 14.40
])
ArithmeticModel.__init__(self, name, (self.ebv, ))
