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])