def init_function_pars():
global FUNCTION_PAR_NAMES
global FUNCTION_NORM_PARS
global FUNCTION_DEFAULT_PARS
FUNCTION_PAR_NAMES = {}
FUNCTION_NORM_PARS = {}
funcFactory = pyLike.SourceFactory_funcFactory()
names = pyLike.StringVector()
funcFactory.getFunctionNames(names)
for fname in names:
pars = FUNCTION_DEFAULT_PARS.setdefault(fname, {})
par_names = FUNCTION_PAR_NAMES.setdefault(fname, [])
if 'EblAtten' in fname and fname[len('EblAtten::'
):] in FUNCTION_DEFAULT_PARS:
pars.update(FUNCTION_DEFAULT_PARS[fname[len('EblAtten::'):]])
fn = funcFactory.create(fname)
try:
FUNCTION_NORM_PARS[fname] = fn.normPar().getName()
except Exception:
FUNCTION_NORM_PARS[fname] = None
params = pyLike.ParameterVector()
fn.getParams(params)
for i, p in enumerate(params):
pname = p.getName()
par_names += [pname]
if pname == 'Scale':
pars.setdefault(pname, DEFAULT_SCALE_DICT)
elif pname == 'Prefactor':
pars.setdefault(pname, DEFAULT_NORM_DICT)
else:
pars.setdefault(pname, {})
bounds = p.getBounds()
par_dict = dict(name=pname,
value=p.getValue(),
min=bounds[0],
max=bounds[1],
scale=1.0,
free=False)
par_dict.update(copy.deepcopy(pars[pname]))
par_dict['name'] = pname
pars[pname] = par_dict
class ModelFunction(object):
_funcFactory = pyLike.SourceFactory_funcFactory()
def __init__(self, xmlFile, srcName):
srcModel = SourceModel(xmlFile)
spectrum = srcModel[srcName].spectrum
self.func = self._funcFactory.create(spectrum.type)
pars = spectrum.parameters
for name in pars.keys():
self.func.setParam(name, pars[name].value)
def __call__(self, ee):
foo = FunctionWrapper(lambda x: self.func.value(pyLike.dArg(x)))
return foo(ee)
def getPointSource(like):
'''This function creats a test source object for use in the likelihood
analysis at a specific pixel.'''
test_src = pyLike.PointSource(0, 0, like.observation.observation)
pl = pyLike.SourceFactory_funcFactory().create('PowerLaw')
pl.setParamValues((1, -2, 100))
indexPar = pl.getParam('Index')
indexPar.setBounds(-3.5, -1)
pl.setParam(indexPar)
prefactor = pl.getParam('Prefactor')
prefactor.setBounds(1e-10, 1e3)
prefactor.setScale(1e-9)
pl.setParam(prefactor)
test_src.setSpectrum(pl)
return test_src
def create_spectrum_from_dict(spectrum_type, spectral_pars, fn=None):
"""Create a Function object from a parameter dictionary.
Parameters
----------
spectrum_type : str
String identifying the spectrum type (e.g. PowerLaw).
spectral_pars : dict
Dictionary of spectral parameters.
"""
if fn is None:
fn = pyLike.SourceFactory_funcFactory().create(str(spectrum_type))
if spectrum_type == 'PiecewisePowerLaw':
build_piecewise_powerlaw(fn, spectral_pars)
for k, v in spectral_pars.items():
v.setdefault('scale', 1.0)
v.setdefault('min', v['value'] * 1E-3)
v.setdefault('max', v['value'] * 1E3)
par = fn.getParam(str(k))
vmin = min(float(v['value']), float(v['min']))
vmax = max(float(v['value']), float(v['max']))
par.setValue(float(v['value']))
par.setBounds(vmin, vmax)
par.setScale(float(v['scale']))
if 'free' in v and int(v['free']) != 0:
par.setFree(True)
else:
par.setFree(False)
fn.setParam(par)
return fn
def create_spectrum_from_dict(spectrum_type, spectral_pars=None, fn=None):
"""Create a Function object from a parameter dictionary.
Parameters
----------
spectrum_type : str
String identifying the spectrum type (e.g. PowerLaw).
spectral_pars : dict
Dictionary of spectral parameters.
"""
pars = create_pars_dict(spectrum_type, spectral_pars)
if fn is None:
fn = pyLike.SourceFactory_funcFactory().create(str(spectrum_type))
for k, v in pars.items():
v = model_utils.make_parameter_dict(v)
par = fn.getParam(str(k))
vmin = min(float(v['value']), float(v['min']))
vmax = max(float(v['value']), float(v['max']))
par.setValue(float(v['value']))
par.setBounds(vmin, vmax)
par.setScale(float(v['scale']))
if 'free' in v and int(v['free']) != 0:
par.setFree(True)
else:
par.setFree(False)
fn.setParam(par)
return fn
"""
Interface to SWIG-wrapped C++ classes.
@author J. Chiang <*****@*****.**>
"""
#
# $Header: /nfs/slac/g/glast/ground/cvs/ScienceTools-scons/pyLikelihood/python/SrcAnalysis.py,v 1.4 2009/03/31 18:20:53 jchiang Exp $
#
import os
import glob
import numpy as num
import pyLikelihood as pyLike
from SrcModel import SourceModel
from SimpleDialog import SimpleDialog, map, Param
_funcFactory = pyLike.SourceFactory_funcFactory()
def _resolveFileList(files):
fileList = files.split(',')
my_list = []
for file in fileList:
my_list.extend(glob.glob(file.strip()))
return my_list
class Observation(object):
def __init__(self, eventFile=None, scFile=None, expMap=None,
expCube=None, irfs='TEST', checkCuts=True):
self.checkCuts = checkCuts
if eventFile is None and scFile is None:
eventFile, scFile, expMap, expCube, irfs = self._obsDialog()
if checkCuts:
""" Module to convert from gtlike to pointlike spectral models (and vice-verca).
"""
import numpy as np
import pyLikelihood
from uw.like.Models import FileFunction
from uw.utilities.parmap import LimitMapper, LinearMapper
from uw.utilities.xml_parsers import XML_to_Model
from .save import spectrum_to_dict
from .load import dict_to_spectrum
_funcFactory = pyLikelihood.SourceFactory_funcFactory()
def gtlike_unscale_all_parameters(spectrum):
""" kind of a kluge. """
return dict_to_spectrum(spectrum_to_dict(spectrum))
def build_gtlike_spectrum(model):
""" Convert a pointlike uw.like.Models.Model to a pyLikelihood spectral model object.
Convert a pointlike model to a gtlike model:
>>> import pyLikelihood
>>> from uw.like.Models import PowerLaw
>>> pointlike_model = PowerLaw()
You cannot convert models unless they have limits on all parameters: