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='psfmodel', kernel=None): self._name = name self._size = None self._origin = None self._center = None self._must_rebin = False 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 self.data_space = None self.psf_space = None Model.__init__(self, name)
def __init__(self, name='emissionvoigt'): self.center = Parameter(name, 'center', 5000., tinyval, hard_min=tinyval, frozen=True, units="angstroms") self.flux = Parameter(name, 'flux', 1.) self.fwhm = Parameter(name, 'fwhm', 100., tinyval, hard_min=tinyval, units="km/s") self.lg = Parameter(name, 'lg', 1., tinyval, hard_min=tinyval, frozen=True) # Create core and wings from Gaussian and Lorentz self._core = EmissionGaussian() self._wings = EmissionLorentz() ArithmeticModel.__init__(self, name, (self.center, self.flux, self.fwhm, self.lg))
class Beta1D(ArithmeticModel): def __init__(self, name='beta1d'): self.r0 = Parameter(name, 'r0', 1, tinyval, hard_min=tinyval) self.beta = Parameter(name, 'beta', 1, 1e-05, 10, 1e-05, 10) self.xpos = Parameter(name, 'xpos', 0, 0, frozen=True) self.ampl = Parameter(name, 'ampl', 1, 0) ArithmeticModel.__init__(self, name, (self.r0, self.beta, self.xpos, self.ampl)) def get_center(self): return (self.xpos.val,) def set_center(self, xpos, *args, **kwargs): self.xpos.set(xpos) def guess(self, dep, *args, **kwargs): pos = get_position(dep, *args) param_apply_limits(pos, self.xpos, **kwargs) ref = guess_reference(self.r0.min, self.r0.max, *args) param_apply_limits(ref, self.r0, **kwargs) norm = guess_amplitude_at_ref(self.r0.val, dep, *args) param_apply_limits(norm, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.beta1d(*args, **kwargs)
def __init__(self, name='blackbody'): 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") self._argmin = 1.0e-3 self._argmax = 1000.0 ArithmeticModel.__init__(self, name, (self.refer, self.ampl, self.temperature))
def __init__(self, modelname, data): self.U = data['U'] self.V = numpy.matrix(data['components']) self.mean = data['mean'] self.s = data['values'] self.ilo = data['ilo'] self.ihi = data['ihi'] p0 = Parameter(modelname=modelname, name='lognorm', val=1, min=-5, max=20, hard_min=-100, hard_max=100) pars = [p0] for i in range(len(self.s)): pi = Parameter(modelname=modelname, name='PC%d' % (i + 1), val=0, min=-20, max=20, hard_min=-1e300, hard_max=1e300) pars.append(pi) super(ArithmeticModel, self).__init__(modelname, pars=pars)
class NormBeta1D(ArithmeticModel): def __init__(self, name='normbeta1d'): self.pos = Parameter(name, 'pos', 0) self.width = Parameter(name, 'width', 1, tinyval, hard_min=tinyval) self.index = Parameter(name, 'index', 2.5, 0.5, 1000, 0.5) self.ampl = Parameter(name, 'ampl', 1, 0) ArithmeticModel.__init__(self, name, (self.pos, self.width, self.index, self.ampl)) def get_center(self): return (self.pos.val,) def set_center(self, pos, *args, **kwargs): self.pos.set(pos) def guess(self, dep, *args, **kwargs): ampl = guess_amplitude(dep, *args) pos = get_position(dep, *args) fwhm = guess_fwhm(dep, *args) param_apply_limits(pos, self.pos, **kwargs) norm = (fwhm['val']*numpy.sqrt(numpy.pi)* numpy.exp(lgam(self.index.val-0.5)-lgam(self.index.val))) for key in ampl.keys(): ampl[key] *= norm param_apply_limits(ampl, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.nbeta1d(*args, **kwargs)
class Lorentz1D(ArithmeticModel): def __init__(self, name='lorentz1d'): self.fwhm = Parameter(name, 'fwhm', 10, 0, hard_min=0) self.pos = Parameter(name, 'pos', 1) self.ampl = Parameter(name, 'ampl', 1) ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl)) def get_center(self): return (self.pos.val,) def set_center(self, pos, *args, **kwargs): self.pos.set(pos) def guess(self, dep, *args, **kwargs): pos = get_position(dep, *args) fwhm = guess_fwhm(dep, *args) param_apply_limits(pos, self.pos, **kwargs) param_apply_limits(fwhm, self.fwhm, **kwargs) norm = guess_amplitude(dep, *args) if fwhm != 10: aprime = norm['val']*self.fwhm.val*numpy.pi/2. ampl = {'val': aprime, 'min': aprime/_guess_ampl_scale, 'max': aprime*_guess_ampl_scale} param_apply_limits(ampl, self.ampl, **kwargs) else: param_apply_limits(norm, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.lorentz1d(*args, **kwargs)
def __init__(self, name='linebroad'): self.ampl = Parameter(name, 'ampl', 1, 0, hard_min=0) self.rest = Parameter(name, 'rest', 1000, tinyval, hard_min=tinyval) self.vsini = Parameter(name, 'vsini', tinyval, tinyval, hard_min=tinyval) ArithmeticModel.__init__(self, name, (self.ampl, self.rest, self.vsini))
class HubbleReynolds(ArithmeticModel): def __init__(self, name='hubblereynolds'): 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, 0, 2*numpy.pi, -2*numpy.pi, 4*numpy.pi, 'radians') self.ampl = Parameter(name, 'ampl', 1) ArithmeticModel.__init__(self, name, (self.r0, self.xpos, self.ypos, self.ellip, self.theta, self.ampl)) self.cache = 0 def get_center(self): return (self.xpos.val, self.ypos.val) def set_center(self, xpos, ypos, *args, **kwargs): self.xpos.set(xpos) self.ypos.set(ypos) def guess(self, dep, *args, **kwargs): xpos, ypos = guess_position(dep, *args) norm = guess_amplitude2d(dep, *args) rad = guess_radius(*args) param_apply_limits(xpos, self.xpos, **kwargs) param_apply_limits(ypos, self.ypos, **kwargs) param_apply_limits(norm, self.ampl, **kwargs) param_apply_limits(rad, self.r0, **kwargs) def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.hr(*args, **kwargs)
def __init__(self, name='beta1d'): self.r0 = Parameter(name, 'r0', 1, tinyval, hard_min=tinyval) self.beta = Parameter(name, 'beta', 1, 1e-05, 10, 1e-05, 10) self.xpos = Parameter(name, 'xpos', 0, 0, frozen=True) self.ampl = Parameter(name, 'ampl', 1, 0) ArithmeticModel.__init__(self, name, (self.r0, self.beta, self.xpos, self.ampl))
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='normbeta1d'): self.pos = Parameter(name, 'pos', 0) self.width = Parameter(name, 'width', 1, tinyval, hard_min=tinyval) self.index = Parameter(name, 'index', 2.5, 0.5, 1000, 0.5) self.ampl = Parameter(name, 'ampl', 1, 0) ArithmeticModel.__init__(self, name, (self.pos, self.width, self.index, self.ampl))
class Sersic2D(ArithmeticModel): 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 get_center(self): return (self.xpos.val, self.ypos.val) def set_center(self, xpos, ypos, *args, **kwargs): self.xpos.set(xpos) self.ypos.set(ypos) def guess(self, dep, *args, **kwargs): xpos, ypos = guess_position(dep, *args) norm = guess_amplitude2d(dep, *args) rad = guess_radius(*args) param_apply_limits(xpos, self.xpos, **kwargs) param_apply_limits(ypos, self.ypos, **kwargs) param_apply_limits(norm, self.ampl, **kwargs) param_apply_limits(rad, self.r0, **kwargs) def calc(self, *args, **kwargs): kwargs['integrate'] = bool_cast(self.integrate) return _modelfcts.sersic(*args, **kwargs)
class Beta1D(ArithmeticModel): def __init__(self, name='beta1d'): self.r0 = Parameter(name, 'r0', 1, tinyval, hard_min=tinyval) self.beta = Parameter(name, 'beta', 1, 1e-05, 10, 1e-05, 10) self.xpos = Parameter(name, 'xpos', 0, 0, frozen=True) self.ampl = Parameter(name, 'ampl', 1, 0) ArithmeticModel.__init__(self, name, (self.r0, self.beta, self.xpos, self.ampl)) def get_center(self): return (self.xpos.val, ) def set_center(self, xpos, *args, **kwargs): self.xpos.set(xpos) def guess(self, dep, *args, **kwargs): pos = get_position(dep, *args) param_apply_limits(pos, self.xpos, **kwargs) ref = guess_reference(self.r0.min, self.r0.max, *args) param_apply_limits(ref, self.r0, **kwargs) norm = guess_amplitude_at_ref(self.r0.val, dep, *args) param_apply_limits(norm, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate'] = bool_cast(self.integrate) return _modelfcts.beta1d(*args, **kwargs)
def __init__(self, name='recombination'): 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") self.fwhm = Parameter(name, 'fwhm', 100., tinyval, hard_min=tinyval, units="km/s") ArithmeticModel.__init__( self, name, (self.refer, self.ampl, self.temperature, self.fwhm))
def __init__(self, name='logemission'): 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.skew = Parameter(name, 'skew', 1., tinyval, frozen=True) self.limit = Parameter(name, 'limit', 4., alwaysfrozen=True, hidden=True) ArithmeticModel.__init__( self, name, (self.fwhm, self.pos, self.flux, self.skew, self.limit))
class Lorentz1D(ArithmeticModel): def __init__(self, name='lorentz1d'): self.fwhm = Parameter(name, 'fwhm', 10, 0, hard_min=0) self.pos = Parameter(name, 'pos', 1) self.ampl = Parameter(name, 'ampl', 1) ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl)) def get_center(self): return (self.pos.val, ) def set_center(self, pos, *args, **kwargs): self.pos.set(pos) def guess(self, dep, *args, **kwargs): pos = get_position(dep, *args) fwhm = guess_fwhm(dep, *args) param_apply_limits(pos, self.pos, **kwargs) param_apply_limits(fwhm, self.fwhm, **kwargs) norm = guess_amplitude(dep, *args) if fwhm != 10: aprime = norm['val'] * self.fwhm.val * numpy.pi / 2. ampl = { 'val': aprime, 'min': aprime / _guess_ampl_scale, 'max': aprime * _guess_ampl_scale } param_apply_limits(ampl, self.ampl, **kwargs) else: param_apply_limits(norm, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate'] = bool_cast(self.integrate) return _modelfcts.lorentz1d(*args, **kwargs)
class NormBeta1D(ArithmeticModel): def __init__(self, name='normbeta1d'): self.pos = Parameter(name, 'pos', 0) self.width = Parameter(name, 'width', 1, tinyval, hard_min=tinyval) self.index = Parameter(name, 'index', 2.5, 0.5, 1000, 0.5) self.ampl = Parameter(name, 'ampl', 1, 0) ArithmeticModel.__init__(self, name, (self.pos, self.width, self.index, self.ampl)) def get_center(self): return (self.pos.val, ) def set_center(self, pos, *args, **kwargs): self.pos.set(pos) def guess(self, dep, *args, **kwargs): ampl = guess_amplitude(dep, *args) pos = get_position(dep, *args) fwhm = guess_fwhm(dep, *args) param_apply_limits(pos, self.pos, **kwargs) norm = (fwhm['val'] * numpy.sqrt(numpy.pi) * numpy.exp(lgam(self.index.val - 0.5) - lgam(self.index.val))) for key in ampl.keys(): ampl[key] *= norm param_apply_limits(ampl, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate'] = bool_cast(self.integrate) return _modelfcts.nbeta1d(*args, **kwargs)
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)
class Lorentz2D(ArithmeticModel): 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, 0, 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 get_center(self): return (self.xpos.val, self.ypos.val) def set_center(self, xpos, ypos, *args, **kwargs): self.xpos.set(xpos) self.ypos.set(ypos) def guess(self, dep, *args, **kwargs): xpos, ypos = guess_position(dep, *args) norm = guess_amplitude2d(dep, *args) param_apply_limits(xpos, self.xpos, **kwargs) param_apply_limits(ypos, self.ypos, **kwargs) param_apply_limits(norm, self.ampl, **kwargs) def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.lorentz2d(*args, **kwargs)
def __init__(self, name='edge'): self.space = Parameter(name, 'space', 0, 0, 1, 0, 1, '0 - energy | 1 - wave') self.thresh = Parameter(name, 'thresh', 1, 0, hard_min=0) self.abs = Parameter(name, 'abs', 1, 0) ArithmeticModel.__init__(self, name, (self.space, self.thresh, self.abs))
def __init__(self, name="Bremsstrahlung"): self.name = name self.n0 = Parameter( name, "n0", 1, min=0, max=1e20, frozen=True, units="1/cm3" ) self.weight_ee = Parameter( name, "weight_ee", 1.088, min=0, max=10, frozen=True ) self.weight_ep = Parameter( name, "weight_ep", 1.263, min=0, max=10, frozen=True ) # add ECPL params super().__init__(name=name) # Initialize model ArithmeticModel.__init__( self, name, ( self.index, self.ref, self.ampl, self.cutoff, self.beta, self.n0, self.weight_ee, self.weight_ep, self.distance, self.verbose, ), ) self._use_caching = True self.cache = 10
def __init__(self, name="IC"): self.name = name self.TFIR = Parameter(name, "TFIR", 30, min=0, frozen=True, units="K") self.uFIR = Parameter( name, "uFIR", 0.0, min=0, frozen=True, units="eV/cm3" ) # , 0.2eV/cm3 typical in outer disk self.TNIR = Parameter( name, "TNIR", 3000, min=0, frozen=True, units="K" ) self.uNIR = Parameter( name, "uNIR", 0.0, min=0, frozen=True, units="eV/cm3" ) # , 0.2eV/cm3 typical in outer disk # add ECPL params super().__init__(name=name) # Initialize model ArithmeticModel.__init__( self, name, ( self.index, self.ref, self.ampl, self.cutoff, self.beta, self.TFIR, self.uFIR, self.TNIR, self.uNIR, self.distance, self.verbose, ), ) self._use_caching = True self.cache = 10
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 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='bpl1d'): self.gamma1 = Parameter(name, 'gamma1', 0, -10, 10) self.gamma2 = Parameter(name, 'gamma2', 0, -10, 10) self.eb = Parameter(name, 'eb', 100, 0, 1000, 0) self.ref = Parameter(name, 'ref', 1, frozen=True) self.ampl = Parameter(name, 'ampl', 1, 1e-20) ArithmeticModel.__init__(self, name, (self.gamma1, self.gamma2, self.eb, self.ref, self.ampl))
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='hubblereynolds'): 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, 0, 2*numpy.pi, -2*numpy.pi, 4*numpy.pi, 'radians') self.ampl = Parameter(name, 'ampl', 1) ArithmeticModel.__init__(self, name, (self.r0, self.xpos, self.ypos, self.ellip, self.theta, self.ampl)) self.cache = 0
class Synchrotron(ArithmeticModel): def __init__(self,name='IC'): self.index = Parameter(name, 'index', 2.0, min=-10, max=10) self.ref = Parameter(name, 'ref', 20, min=0, frozen=True, units='TeV') self.ampl = Parameter(name, 'ampl', 1, min=0, max=1e60, hard_max=1e100, units='1e30/eV') self.cutoff = Parameter(name, 'cutoff', 0.0, min=0,frozen=True, units='TeV') self.beta = Parameter(name, 'beta', 1, min=0, max=10, frozen=True) self.B = Parameter(name, 'B', 1, min=0, max=10, frozen=True, units='G') self.verbose = Parameter(name, 'verbose', 0, min=0, frozen=True) ArithmeticModel.__init__(self,name,(self.index,self.ref,self.ampl,self.cutoff,self.beta,self.B,self.verbose)) self._use_caching = True self.cache = 10 def guess(self,dep,*args,**kwargs): # guess normalization from total flux xlo,xhi=args model=self.calc([p.val for p in self.pars],xlo,xhi) modflux=trapz_loglog(model,xlo) obsflux=trapz_loglog(dep*(xhi-xlo),xlo) self.ampl.set(self.ampl.val*obsflux/modflux) @modelCacher1d def calc(self,p,x,xhi=None): index,ref,ampl,cutoff,beta,B,verbose = p # Sherpa provides xlo, xhi in KeV, we merge into a single array if bins required if xhi is None: outspec = x * u.keV else: outspec = _mergex(x,xhi) * u.keV if cutoff == 0.0: pdist = models.PowerLaw(ampl * 1e30 * u.Unit('1/eV'), ref * u.TeV, index) else: pdist = models.ExponentialCutoffPowerLaw(ampl * 1e30 * u.Unit('1/eV'), ref * u.TeV, index, cutoff * u.TeV, beta=beta) sy = models.Synchrotron(pdist, B=B*u.G, log10gmin=5, log10gmax=10, ngamd=50) model = sy.flux(outspec, distance=1*u.kpc).to('1/(s cm2 keV)') # Do a trapz integration to obtain the photons per bin if xhi is None: photons = (model * outspec).to('1/(s cm2)').value else: photons = trapz_loglog(model,outspec,intervals=True).to('1/(s cm2)').value if verbose: print(self.thawedpars, trapz_loglog(outspec*model,outspec).to('erg/(s cm2)')) return photons
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='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, 0, 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='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, 0, 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='beta2d'): self.r0 = Parameter(name, 'r0', 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, 0, 2*numpy.pi, -2*numpy.pi, 4*numpy.pi, 'radians', True) self.ampl = Parameter(name, 'ampl', 1) self.alpha = Parameter(name, 'alpha', 1, -10, 10) ArithmeticModel.__init__(self, name, (self.r0, self.xpos, self.ypos, self.ellip, self.theta, self.ampl, self.alpha)) self.cache = 0
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='pp'): self.index = Parameter(name , 'index' , 2.1 , min=-10 , max=10) self.ref = Parameter(name , 'ref' , 60 , min=0 , frozen=True , units='TeV') self.ampl = Parameter(name , 'ampl' , 100 , min=0 , max=1e60 , hard_max=1e100 , units='1e30/eV') self.cutoff = Parameter(name , 'cutoff' , 0 , min=0 , frozen=True , units='TeV') self.beta = Parameter(name , 'beta' , 1 , min=0 , max=10 , frozen=True) self.nh = Parameter(name , 'nH' , 1 , min=0 , frozen=True , units='1/cm3') self.verbose = Parameter(name , 'verbose' , 0 , min=0 , frozen=True) ArithmeticModel.__init__(self,name,(self.index,self.ref,self.ampl,self.cutoff,self.beta,self.nh,self.verbose)) self._use_caching = True self.cache = 10
def __init__(self,name='IC'): self.index = Parameter(name, 'index', 2.0, min=-10, max=10) self.ref = Parameter(name, 'ref', 20, min=0, frozen=True, units='TeV') self.ampl = Parameter(name, 'ampl', 1, min=0, max=1e60, hard_max=1e100, units='1e30/eV') self.cutoff = Parameter(name, 'cutoff', 0.0, min=0,frozen=True, units='TeV') self.beta = Parameter(name, 'beta', 1, min=0, max=10, frozen=True) self.TFIR = Parameter(name, 'TFIR', 70, min=0, frozen=True, units='K') self.uFIR = Parameter(name, 'uFIR', 0.0, min=0, frozen=True, units='eV/cm3') # 0.2eV/cm3 typical in outer disk self.TNIR = Parameter(name, 'TNIR', 3800, min=0, frozen=True, units='K') self.uNIR = Parameter(name, 'uNIR', 0.0, min=0, frozen=True, units='eV/cm3') # 0.2eV/cm3 typical in outer disk self.verbose = Parameter(name, 'verbose', 0, min=0, frozen=True) ArithmeticModel.__init__(self,name,(self.index,self.ref,self.ampl,self.cutoff,self.beta, self.TFIR, self.uFIR, self.TNIR, self.uNIR, self.verbose)) self._use_caching = True self.cache = 10
def setUp(self): self.p = Parameter('model', 'name', 0, -10, 10, -100, 100, 'units') self.afp = Parameter('model', 'name', 0, alwaysfrozen=True)
class InverseCompton(ArithmeticModel): def __init__(self,name='IC'): self.index = Parameter(name, 'index', 2.0, min=-10, max=10) self.ref = Parameter(name, 'ref', 20, min=0, frozen=True, units='TeV') self.ampl = Parameter(name, 'ampl', 1, min=0, max=1e60, hard_max=1e100, units='1e30/eV') self.cutoff = Parameter(name, 'cutoff', 0.0, min=0,frozen=True, units='TeV') self.beta = Parameter(name, 'beta', 1, min=0, max=10, frozen=True) self.TFIR = Parameter(name, 'TFIR', 70, min=0, frozen=True, units='K') self.uFIR = Parameter(name, 'uFIR', 0.0, min=0, frozen=True, units='eV/cm3') # 0.2eV/cm3 typical in outer disk self.TNIR = Parameter(name, 'TNIR', 3800, min=0, frozen=True, units='K') self.uNIR = Parameter(name, 'uNIR', 0.0, min=0, frozen=True, units='eV/cm3') # 0.2eV/cm3 typical in outer disk self.verbose = Parameter(name, 'verbose', 0, min=0, frozen=True) ArithmeticModel.__init__(self,name,(self.index,self.ref,self.ampl,self.cutoff,self.beta, self.TFIR, self.uFIR, self.TNIR, self.uNIR, self.verbose)) self._use_caching = True self.cache = 10 def guess(self,dep,*args,**kwargs): # guess normalization from total flux xlo,xhi=args model=self.calc([p.val for p in self.pars],xlo,xhi) modflux=trapz_loglog(model,xlo) obsflux=trapz_loglog(dep*(xhi-xlo),xlo) self.ampl.set(self.ampl.val*obsflux/modflux) @modelCacher1d def calc(self,p,x,xhi=None): index,ref,ampl,cutoff,beta,TFIR,uFIR,TNIR,uNIR,verbose = p # Sherpa provides xlo, xhi in KeV, we merge into a single array if bins required if xhi is None: outspec = x * u.keV else: outspec = _mergex(x,xhi) * u.keV if cutoff == 0.0: pdist = models.PowerLaw(ampl * 1e30 * u.Unit('1/eV'), ref * u.TeV, index) else: pdist = models.ExponentialCutoffPowerLaw(ampl * 1e30 * u.Unit('1/eV'), ref * u.TeV, index, cutoff * u.TeV, beta=beta) # Build seedspec definition seedspec=['CMB',] if uFIR>0.0: seedspec.append(['FIR',TFIR * u.K, uFIR * u.eV/u.cm**3]) if uNIR>0.0: seedspec.append(['NIR',TNIR * u.K, uNIR * u.eV/u.cm**3]) ic = models.InverseCompton(pdist, seed_photon_fields=seedspec, log10gmin=5, log10gmax=10, ngamd=100) model = ic.flux(outspec, distance=1*u.kpc).to('1/(s cm2 keV)') # Do a trapz integration to obtain the photons per bin if xhi is None: photons = (model * outspec).to('1/(s cm2)').value else: photons = trapz_loglog(model,outspec,intervals=True).to('1/(s cm2)').value if verbose: print(self.thawedpars, trapz_loglog(outspec*model,outspec).to('erg/(s cm2)')) return photons
class NormBeta1D(ArithmeticModel): """One-dimensional normalized beta model function. This is the same model as the ``Beta1D`` model but with a different slope parameter and normalisation. Attributes ---------- pos The center of the line. w The line width. alpha The slope of the profile at large radii. ampl The amplitude refers to the integral of the model. See Also -------- Beta1D, Lorentz1D Notes ----- The functional form of the model for points is:: f(x) = A * (1 + ((x - pos) / w)^2)^(-alpha) A = ampl / integral f(x) dx The grid version is evaluated by numerically intgerating the function over each bin using a non-adaptive Gauss-Kronrod scheme suited for smooth functions [1]_, falling over to a simple trapezoid scheme if this fails. References ---------- .. [1] https://www.gnu.org/software/gsl/manual/html_node/QNG-non_002dadaptive-Gauss_002dKronrod-integration.html """ def __init__(self, name='normbeta1d'): self.pos = Parameter(name, 'pos', 0) self.width = Parameter(name, 'width', 1, tinyval, hard_min=tinyval) self.index = Parameter(name, 'index', 2.5, 0.5, 1000, 0.5) self.ampl = Parameter(name, 'ampl', 1, 0) ArithmeticModel.__init__(self, name, (self.pos, self.width, self.index, self.ampl)) def get_center(self): return (self.pos.val,) def set_center(self, pos, *args, **kwargs): self.pos.set(pos) def guess(self, dep, *args, **kwargs): ampl = guess_amplitude(dep, *args) pos = get_position(dep, *args) fwhm = guess_fwhm(dep, *args) param_apply_limits(pos, self.pos, **kwargs) norm = (fwhm['val']*numpy.sqrt(numpy.pi)* numpy.exp(lgam(self.index.val-0.5)-lgam(self.index.val))) for key in ampl.keys(): ampl[key] *= norm param_apply_limits(ampl, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.nbeta1d(*args, **kwargs)
class test_parameter(SherpaTestCase): def setUp(self): self.p = Parameter('model', 'name', 0, -10, 10, -100, 100, 'units') self.afp = Parameter('model', 'name', 0, alwaysfrozen=True) def test_name(self): self.assertEqual(self.p.modelname, 'model') self.assertEqual(self.p.name, 'name') self.assertEqual(self.p.fullname, 'model.name') def test_alwaysfrozen(self): self.assertTrue(self.afp.frozen) self.afp.frozen = True self.assertTrue(self.afp.frozen) self.afp.freeze() self.assertTrue(self.afp.frozen) self.assertRaises(ParameterErr, self.afp.thaw) self.assertRaises(ParameterErr, setattr, self.afp, 'frozen', 0) def test_readonly_attributes(self): self.assertEqual(self.p.alwaysfrozen, False) self.assertRaises(AttributeError, setattr, self.p, 'alwaysfrozen', 1) self.assertEqual(self.p.hard_min, -100.0) self.assertRaises(AttributeError, setattr, self.p, 'hard_min', -1000) self.assertEqual(self.p.hard_max, 100.0) self.assertRaises(AttributeError, setattr, self.p, 'hard_max', 1000) def test_val(self): self.p.val = -7 self.assertEqual(self.p.val, -7) self.assertTrue(type(self.p.val) is SherpaFloat) self.assertRaises(ValueError, setattr, self.p, 'val', 'ham') self.assertRaises(ParameterErr, setattr, self.p, 'val', -101) self.assertRaises(ParameterErr, setattr, self.p, 'val', 101) def test_min_max(self): for attr, sign in (('min', -1), ('max', 1)): setattr(self.p, attr, sign * 99) val = getattr(self.p, attr) self.assertEqual(val, sign * 99) self.assertTrue(type(val) is SherpaFloat) self.assertRaises(ValueError, setattr, self.p, attr, 'ham') self.assertRaises(ParameterErr, setattr, self.p, attr, -101) self.assertRaises(ParameterErr, setattr, self.p, attr, 101) def test_frozen(self): self.p.frozen = 1.0 self.assertTrue(self.p.frozen is True) self.p.frozen = [] self.assertTrue(self.p.frozen is False) self.assertRaises(TypeError, setattr, self.p.frozen, arange(10)) self.p.link = self.afp self.assertTrue(self.p.frozen is True) self.p.link = None self.p.freeze() self.assertTrue(self.p.frozen is True) self.p.thaw() self.assertTrue(self.p.frozen is False) def test_link(self): self.p.link = None self.assertTrue(self.p.link is None) self.assertNotEqual(self.p.val, 17.3) self.afp.val = 17.3 self.p.link = self.afp self.assertEqual(self.p.val, 17.3) self.p.unlink() self.assertTrue(self.p.link is None) self.assertRaises(ParameterErr, setattr, self.afp, 'link', self.p) self.assertRaises(ParameterErr, setattr, self.p, 'link', 3) self.assertRaises(ParameterErr, setattr, self.p, 'link', 3 * self.p + 2) def test_iter(self): for part in self.p: self.assertTrue(part is self.p)
class Lorentz1D(ArithmeticModel): """One-dimensional normalized Lorentz model function. Attributes ---------- fwhm The full-width half maximum of the line. pos The center of the line. ampl The amplitude refers to the integral of the model. See Also -------- Beta1D, NormBeta1D Notes ----- The functional form of the model for points is:: f(x) = A * fwhm -------------------------------------- 2 * pi * (0.25 * fwhm^2 + (x - pos)^2) A = ampl / integral f(x) dx and for an integrated grid it is the integral of this over the bin. """ def __init__(self, name='lorentz1d'): self.fwhm = Parameter(name, 'fwhm', 10, 0, hard_min=0) self.pos = Parameter(name, 'pos', 1) self.ampl = Parameter(name, 'ampl', 1) ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl)) def get_center(self): return (self.pos.val,) def set_center(self, pos, *args, **kwargs): self.pos.set(pos) def guess(self, dep, *args, **kwargs): pos = get_position(dep, *args) fwhm = guess_fwhm(dep, *args) param_apply_limits(pos, self.pos, **kwargs) param_apply_limits(fwhm, self.fwhm, **kwargs) norm = guess_amplitude(dep, *args) if fwhm != 10: aprime = norm['val']*self.fwhm.val*numpy.pi/2. ampl = {'val': aprime, 'min': aprime/_guess_ampl_scale, 'max': aprime*_guess_ampl_scale} param_apply_limits(ampl, self.ampl, **kwargs) else: param_apply_limits(norm, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.lorentz1d(*args, **kwargs)
def __init__(self, name='lorentz1d'): self.fwhm = Parameter(name, 'fwhm', 10, 0, hard_min=0) self.pos = Parameter(name, 'pos', 1) self.ampl = Parameter(name, 'ampl', 1) ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl))
class Sersic2D(ArithmeticModel): """Two-dimensional Sersic model. This is a generalization of the ``DeVaucouleurs2D`` model, in which the exponent ``n`` can vary ([1]_, [2]_, and [3]_). Attributes ---------- r0 The core radius. xpos The center of the model on the x0 axis. ypos The center of the model on the x1 axis. ellip The ellipticity of the model. theta The angle of the major axis. It is in radians, measured counter-clockwise from the X0 axis (i.e. the line X1=0). ampl The amplitude refers to the maximum peak of the model. n The Sersic index (n=4 replicates the ``DeVaucouleurs2D`` model). See Also -------- Beta2D, DeVaucouleurs2D, HubbleReynolds, Lorentz2D Notes ----- The functional form of the model for points is can be expressed as the following:: f(x0,x1) = ampl * exp(-b(n) * (r(x0,x1)^(1/n) - 1)) b(n) = 2 * n - 1 / 3 + 4 / (405 * n) + 46 / (25515 * n^2) r(x0,x1)^2 = xoff(x0,x1)^2 * (1-ellip)^2 + yoff(x0,x1)^2 ------------------------------------------- r0^2 * (1-ellip)^2 xoff(x0,x1) = (x0 - xpos) * cos(theta) + (x1 - ypos) * sin(theta) yoff(x0,x1) = (x1 - ypos) * cos(theta) - (x0 - xpos) * sin(theta) The grid version is evaluated by adaptive multidimensional integration scheme on hypercubes using cubature rules, based on code from HIntLib ([4]_) and GSL ([5]_). References ---------- .. [1] http://ned.ipac.caltech.edu/level5/March05/Graham/Graham2.html .. [2] Graham, A. & Driver, S., 2005, PASA, 22, 118 http://adsabs.harvard.edu/abs/2005PASA...22..118G .. [3] Ciotti, L. & Bertin, G., A&A, 1999, 352, 447-451 http://adsabs.harvard.edu/abs/1999A%26A...352..447C .. [4] HIntLib - High-dimensional Integration Library http://mint.sbg.ac.at/HIntLib/ .. [5] GSL - GNU Scientific Library http://www.gnu.org/software/gsl/ """ 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 get_center(self): return (self.xpos.val, self.ypos.val) def set_center(self, xpos, ypos, *args, **kwargs): self.xpos.set(xpos) self.ypos.set(ypos) def guess(self, dep, *args, **kwargs): xpos, ypos = guess_position(dep, *args) norm = guess_amplitude2d(dep, *args) rad = guess_radius(*args) param_apply_limits(xpos, self.xpos, **kwargs) param_apply_limits(ypos, self.ypos, **kwargs) param_apply_limits(norm, self.ampl, **kwargs) param_apply_limits(rad, self.r0, **kwargs) def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.sersic(*args, **kwargs)
class Beta2D(RegriddableModel2D): """Two-dimensional beta model function. The beta model is a Lorentz model with a varying power law. Attributes ---------- r0 The core radius. xpos X0 axis coordinate of the model center (position of the peak). ypos X1 axis coordinate of the model center (position of the peak). ellip The ellipticity of the model. theta The angle of the major axis. It is in radians, measured counter-clockwise from the X0 axis (i.e. the line X1=0). ampl The model value at the peak position (xpos, ypos). alpha The power-law slope of the profile at large radii. See Also -------- Beta1D, DeVaucouleurs2D, HubbleReynolds, Lorentz2D, Sersic2D Notes ----- The functional form of the model for points is:: f(x0,x1) = ampl * (1 + r(x0,x1)^2)^(-alpha) r(x0,x1)^2 = xoff(x0,x1)^2 * (1-ellip)^2 + yoff(x0,x1)^2 ------------------------------------------- r0^2 * (1-ellip)^2 xoff(x0,x1) = (x0 - xpos) * cos(theta) + (x1 - ypos) * sin(theta) yoff(x0,x1) = (x1 - ypos) * cos(theta) - (x0 - xpos) * sin(theta) The grid version is evaluated by adaptive multidimensional integration scheme on hypercubes using cubature rules, based on code from HIntLib ([1]_) and GSL ([2]_). References ---------- .. [1] HIntLib - High-dimensional Integration Library http://mint.sbg.ac.at/HIntLib/ .. [2] GSL - GNU Scientific Library http://www.gnu.org/software/gsl/ """ def __init__(self, name='beta2d'): self.r0 = Parameter(name, 'r0', 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', True) self.ampl = Parameter(name, 'ampl', 1) self.alpha = Parameter(name, 'alpha', 1, -10, 10) ArithmeticModel.__init__(self, name, (self.r0, self.xpos, self.ypos, self.ellip, self.theta, self.ampl, self.alpha)) self.cache = 0 def get_center(self): return (self.xpos.val, self.ypos.val) def set_center(self, xpos, ypos, *args, **kwargs): self.xpos.set(xpos) self.ypos.set(ypos) def guess(self, dep, *args, **kwargs): xpos, ypos = guess_position(dep, *args) norm = guess_amplitude2d(dep, *args) rad = guess_radius(*args) param_apply_limits(xpos, self.xpos, **kwargs) param_apply_limits(ypos, self.ypos, **kwargs) param_apply_limits(norm, self.ampl, **kwargs) param_apply_limits(rad, self.r0, **kwargs) def calc(self, *args, **kwargs): kwargs['integrate'] = bool_cast(self.integrate) return _modelfcts.beta2d(*args, **kwargs)
class DeVaucouleurs2D(ArithmeticModel): """Two-dimensional de Vaucouleurs model. This is a formulation of the R^(1/4) law introduced by [1]_. It is a special case of the ``Sersic2D`` model with ``n=4``, as described in [2]_, [3]_, and [4]_. Attributes ---------- r0 The core radius. xpos The center of the model on the x0 axis. ypos The center of the model on the x1 axis. ellip The ellipticity of the model. theta The angle of the major axis. It is in radians, measured counter-clockwise from the X0 axis (i.e. the line X1=0). ampl The amplitude refers to the maximum peak of the model. See Also -------- Beta2D, HubbleReynolds, Lorentz2D, Sersic2D Notes ----- The model used is the same as the ``Sersic2D`` model with ``n=4``. References ---------- .. [1] de Vaucouleurs G., 1948, Ann. d’Astroph. 11, 247 http://adsabs.harvard.edu/abs/1948AnAp...11..247D .. [2] http://ned.ipac.caltech.edu/level5/March05/Graham/Graham2.html .. [3] Graham, A. & Driver, S., 2005, PASA, 22, 118 http://adsabs.harvard.edu/abs/2005PASA...22..118G .. [4] Ciotti, L. & Bertin, G., A&A, 1999, 352, 447-451 http://adsabs.harvard.edu/abs/1999A%26A...352..447C """ def __init__(self, name='devaucouleurs2d'): 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) ArithmeticModel.__init__(self, name, (self.r0, self.xpos, self.ypos, self.ellip, self.theta, self.ampl)) self.cache = 0 def get_center(self): return (self.xpos.val, self.ypos.val) def set_center(self, xpos, ypos, *args, **kwargs): self.xpos.set(xpos) self.ypos.set(ypos) def guess(self, dep, *args, **kwargs): xpos, ypos = guess_position(dep, *args) norm = guess_amplitude2d(dep, *args) rad = guess_radius(*args) param_apply_limits(xpos, self.xpos, **kwargs) param_apply_limits(ypos, self.ypos, **kwargs) param_apply_limits(norm, self.ampl, **kwargs) param_apply_limits(rad, self.r0, **kwargs) def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.devau(*args, **kwargs)
class Lorentz2D(ArithmeticModel): """Two-dimensional un-normalised Lorentz function. Attributes ---------- fwhm The full-width half maximum. xpos The center of the model on the x0 axis. ypos The center of the model on the x1 axis. ellip The ellipticity of the model. theta The angle of the major axis. It is in radians, measured counter-clockwise from the X0 axis (i.e. the line X1=0). ampl The amplitude refers to the maximum peak of the model. See Also -------- Beta1D, DeVaucouleurs2D, HubbleReynolds, Lorentz1D, Sersic2D Notes ----- The functional form of the model for points is:: f(x0,x1) = ampl / (1 + 4 * r(x0,x1)^2) r(x0,x1)^2 = xoff(x0,x1)^2 * (1-ellip)^2 + yoff(x0,x1)^2 ------------------------------------------- fwhm^2 * (1-ellip)^2 xoff(x0,x1) = (x0 - xpos) * cos(theta) + (x1 - ypos) * sin(theta) yoff(x0,x1) = (x1 - ypos) * cos(theta) - (x0 - xpos) * sin(theta) and for an integrated grid it is the integral of this over the bin. """ 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 get_center(self): return (self.xpos.val, self.ypos.val) def set_center(self, xpos, ypos, *args, **kwargs): self.xpos.set(xpos) self.ypos.set(ypos) def guess(self, dep, *args, **kwargs): xpos, ypos = guess_position(dep, *args) norm = guess_amplitude2d(dep, *args) param_apply_limits(xpos, self.xpos, **kwargs) param_apply_limits(ypos, self.ypos, **kwargs) param_apply_limits(norm, self.ampl, **kwargs) def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.lorentz2d(*args, **kwargs)
class HubbleReynolds(ArithmeticModel): """Two-dimensional Hubble-Reynolds model. Attributes ---------- r0 The core radius. xpos The center of the model on the x0 axis. ypos The center of the model on the x1 axis. ellip The ellipticity of the model. theta The angle of the major axis. It is in radians, measured counter-clockwise from the X0 axis (i.e. the line X1=0). ampl The amplitude refers to the maximum peak of the model. See Also -------- Beta2D, DeVaucouleurs2D, Lorentz2D, Sersic2D Notes ----- The functional form of the model for points is:: f(x0,x1) = ampl / (1 + r(x0,x1))^2 r(x0,x1)^2 = xoff(x0,x1)^2 * (1-ellip)^2 + yoff(x0,x1)^2 ------------------------------------------- r0^2 * (1-ellip)^2 xoff(x0,x1) = (x0 - xpos) * cos(theta) + (x1 - ypos) * sin(theta) yoff(x0,x1) = (x1 - ypos) * cos(theta) - (x0 - xpos) * sin(theta) The grid version is evaluated by adaptive multidimensional integration scheme on hypercubes using cubature rules, based on code from HIntLib ([1]_) and GSL ([2]_). References ---------- .. [1] HIntLib - High-dimensional Integration Library http://mint.sbg.ac.at/HIntLib/ .. [2] GSL - GNU Scientific Library http://www.gnu.org/software/gsl/ """ def __init__(self, name='hubblereynolds'): 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) ArithmeticModel.__init__(self, name, (self.r0, self.xpos, self.ypos, self.ellip, self.theta, self.ampl)) self.cache = 0 def get_center(self): return (self.xpos.val, self.ypos.val) def set_center(self, xpos, ypos, *args, **kwargs): self.xpos.set(xpos) self.ypos.set(ypos) def guess(self, dep, *args, **kwargs): xpos, ypos = guess_position(dep, *args) norm = guess_amplitude2d(dep, *args) rad = guess_radius(*args) param_apply_limits(xpos, self.xpos, **kwargs) param_apply_limits(ypos, self.ypos, **kwargs) param_apply_limits(norm, self.ampl, **kwargs) param_apply_limits(rad, self.r0, **kwargs) def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.hr(*args, **kwargs)
galabso.nH.freeze() galabso.nH.val = props['nhgal'] / 1e22 print('freezing background params') for p in get_bkg_model(id).pars: p.freeze() print(get_model(id)) if id2: for p in get_bkg_model(id2).pars: p.freeze() print(get_model(id2)) print('creating prior functions...') srclevel = Parameter('src', 'level', numpy.log10(sphere.norm.val), -8, 3, -8, 3) srclevel2 = Parameter('src2', 'level', numpy.log10(sphere2.norm.val), -8, 3, -8, 3) srcnh = Parameter('src', 'nh', numpy.log10(sphere.nh.val)+22, 20, 26, 20, 26) galnh = galabso.nH.val sphere.norm = 10**srclevel sphere2.norm = 10**srclevel2 sphere.nh = 10**(srcnh - 22) sphere2.nh = 10**(srcnh - 22) galabso.nH = 10**(galnh - 22) priors = [] parameters = [srclevel, sphere.phoindex, srcnh] import bxa.sherpa as bxa priors += [bxa.create_uniform_prior_for(srclevel)] priors += [bxa.create_gaussian_prior_for(sphere.phoindex, 1.95, 0.15)] priors += [bxa.create_uniform_prior_for(srcnh)]
class Beta1D(ArithmeticModel): """One-dimensional beta model function. The beta model is a Lorentz model with a varying power law. Attributes ---------- r0 The core radius. beta This parameter controls the slope of the profile at large radii. xpos The reference point of the profile. This is frozen by default. ampl The amplitude refers to the maximum value of the model, at x = xpos. See Also -------- Beta2D, Lorentz1D, NormBeta1D Notes ----- The functional form of the model for points is:: f(x) = ampl * (1 + ((x - xpos) / r0)^2)^(0.5 - 3 * beta) The grid version is evaluated by numerically intgerating the function over each bin using a non-adaptive Gauss-Kronrod scheme suited for smooth functions [1]_, falling over to a simple trapezoid scheme if this fails. References ---------- .. [1] https://www.gnu.org/software/gsl/manual/html_node/QNG-non_002dadaptive-Gauss_002dKronrod-integration.html """ def __init__(self, name='beta1d'): self.r0 = Parameter(name, 'r0', 1, tinyval, hard_min=tinyval) self.beta = Parameter(name, 'beta', 1, 1e-05, 10, 1e-05, 10) self.xpos = Parameter(name, 'xpos', 0, 0, frozen=True) self.ampl = Parameter(name, 'ampl', 1, 0) ArithmeticModel.__init__(self, name, (self.r0, self.beta, self.xpos, self.ampl)) def get_center(self): return (self.xpos.val,) def set_center(self, xpos, *args, **kwargs): self.xpos.set(xpos) def guess(self, dep, *args, **kwargs): pos = get_position(dep, *args) param_apply_limits(pos, self.xpos, **kwargs) ref = guess_reference(self.r0.min, self.r0.max, *args) param_apply_limits(ref, self.r0, **kwargs) norm = guess_amplitude_at_ref(self.r0.val, dep, *args) param_apply_limits(norm, self.ampl, **kwargs) @modelCacher1d def calc(self, *args, **kwargs): kwargs['integrate']=bool_cast(self.integrate) return _modelfcts.beta1d(*args, **kwargs)