def __call__(self, xval=100, verbose=0):
x = pyLike.dArg(xval)
y0 = self.func.value(x)
params = pyLike.DoubleVector()
self.func.getFreeParamValues(params)
eps = 1e-7
num_derivs = []
for i in range(len(params)):
new_params = list(params)
delta = new_params[i] * eps
if delta == 0:
delta = eps
new_params[i] += delta
self.func.setFreeParamValues(new_params)
y1 = self.func.value(x)
num_derivs.append((y1 - y0) / delta)
derivs = pyLike.DoubleVector()
self.func.setFreeParamValues(params)
self.func.getFreeDerivs(x, derivs)
for i, d0, d1 in zip(range(len(derivs)), num_derivs, derivs):
try:
assert (compare_floats(d0, d1))
if verbose:
raise AssertionError
except AssertionError:
parnames = pyLike.StringVector()
self.func.getFreeParamNames(parnames)
print "Parameter : ", i, parnames[i]
print "%.3e " * len(num_derivs) % tuple(num_derivs)
print "%.3e " * len(derivs) % tuple(derivs) + "\n"
return tuple(params)
def Ts2(self, srcName, reoptimize=False, approx=True,
tol=None, MaxIterations=10, verbosity=0):
srcName = str(srcName)
if verbosity > 0:
print("*** Start Ts_dl ***")
source_attributes = self.components[0].getExtraSourceAttributes()
self.syncSrcParams()
freeParams = pyLike.DoubleVector()
self.components[0].logLike.getFreeParamValues(freeParams)
logLike1 = -self()
for comp in self.components:
comp.scaleSource(srcName, 1E-10)
comp._ts_src = comp.logLike.getSource(srcName)
free_flag = comp._ts_src.spectrum().normPar().isFree()
if reoptimize:
comp._ts_src.spectrum().normPar().setFree(False)
self.syncSrcParams()
logLike0 = -self()
if tol is None:
tol = self.tol
if reoptimize:
if verbosity > 0:
print("** Do reoptimize")
optFactory = pyLike.OptimizerFactory_instance()
myOpt = optFactory.create(self.optimizer, self.composite)
Niter = 1
while Niter <= MaxIterations:
try:
myOpt.find_min(0, tol)
break
except RuntimeError as e:
print(e)
if verbosity > 0:
print("** Iteration :", Niter)
Niter += 1
else:
if approx:
try:
self._renorm()
except ZeroDivisionError:
pass
self.syncSrcParams()
logLike0 = max(-self(), logLike0)
Ts_value = 2 * (logLike1 - logLike0)
for comp in self.components:
comp.scaleSource(srcName, 1E10)
if reoptimize:
comp._ts_src.spectrum().normPar().setFree(free_flag)
self.syncSrcParams(srcName)
comp.logLike.setFreeParamValues(freeParams)
comp.model = SourceModel(comp.logLike)
for src in source_attributes:
comp.model[src].__dict__.update(source_attributes[src])
self.model = self.components[0].model
return Ts_value
def build_piecewise_powerlaw(fn, spectral_pars):
ppl = pyLike.PiecewisePowerLaw.cast(fn)
index_l = spectral_pars['IndexL']['value']
index_h = spectral_pars['IndexH']['value']
i = 0
energies = pyLike.DoubleVector()
dndes = pyLike.DoubleVector()
while True:
try:
energy = spectral_pars['Energy%i' % i]['value']
dnde = spectral_pars['dNdE%i' % i]['value']
energies.push_back(energy)
dndes.push_back(dnde)
i += 1
except KeyError:
break
ppl.addParams(index_l, index_h, dndes, energies)
def Ts2(self, srcName, reoptimize=False, approx=True,
tol=None, MaxIterations=10, verbosity=0):
"""Computes the TS value for a source indicated by "srcName."
If "reoptimize=True" is selected this function will reoptimize
the model up to "MaxIterations" given the tolerance "tol"
(default is the tolerance selected for the overall fit). If
"appox=True" is selected (the default) it will renormalize the
model (see _renorm).
"""
saved_state = LikelihoodState(self)
if verbosity > 0:
print("*** Start Ts_dl ***")
source_attributes = self.getExtraSourceAttributes()
self.logLike.syncParams()
src = self.logLike.getSource(srcName)
self._ts_src = src
freeParams = pyLike.DoubleVector()
self.logLike.getFreeParamValues(freeParams)
logLike1 = self.logLike.value()
self.scaleSource(srcName, 1E-10)
logLike0 = self.logLike.value()
if tol is None:
tol = self.tol
if reoptimize:
if verbosity > 0:
print("** Do reoptimize")
optFactory = pyLike.OptimizerFactory_instance()
myOpt = optFactory.create(self.optimizer, self.logLike)
Niter = 1
while Niter <= MaxIterations:
try:
myOpt.find_min(0, tol)
break
except RuntimeError as e:
print(e)
if verbosity > 0:
print("** Iteration :", Niter)
Niter += 1
else:
if approx:
try:
self._renorm()
except ZeroDivisionError:
pass
self.logLike.syncParams()
logLike0 = max(self.logLike.value(), logLike0)
Ts_value = 2 * (logLike1 - logLike0)
self.scaleSource(srcName, 1E10)
self.logLike.setFreeParamValues(freeParams)
self.model = SourceModel(self.logLike)
for src in source_attributes:
self.model[src].__dict__.update(source_attributes[src])
saved_state.restore()
self.logLike.value()
return Ts_value
def __init__(self, pylike_object, test_source=None, target="GRB"):
"""
:param pylike_object: a UnbinnedAnalysis.UnbinnedAnalysis object containing a source in the center
"""
self._pylike_object = pylike_object
logLike = self._pylike_object.logLike
# Remove target source (will be replaced with the test source)
self._target_source = logLike.deleteSource(target)
ra = self._pylike_object.model[target]['Position']['RA']
dec = self._pylike_object.model[target]['Position']['DEC']
# Generate a test source (and compute the exposure, since we provide the observation in the constructor)
if test_source is None:
# This is quite slow, so if you can, provide the test source already
self._test_source = pyLikelihood.PointSource(
ra, dec, logLike.observation())
self._test_source.setSpectrum(
self._target_source.spectrum().clone())
self._test_source.setName("_test_source")
else:
self._test_source = test_source
# compute the value for the likelihood without the point source
# Optimize (i.e., fit) the model without the point source
self._pylike_object.optimize(verbosity=0)
logLike0 = logLike.value()
# Store it
self._logLike0 = float(logLike0)
# Save the values for the free parameters in the model without the point source
self._nullhyp_best_fit_param = pyLikelihood.DoubleVector()
# This is a C++ call-by-reference, so self._nullhyp_best_fit_param will be changed
logLike.getFreeParamValues(self._nullhyp_best_fit_param)
def Ts(self,
srcName,
reoptimize=False,
approx=True,
tol=None,
MaxIterations=10,
verbosity=0):
if verbosity > 0:
print "*** Start Ts_dl ***"
source_attributes = self.components[0].getExtraSourceAttributes()
self.syncSrcParams()
freeParams = pyLike.DoubleVector()
self.components[0].logLike.getFreeParamValues(freeParams)
# Get the number of free parameters in the baseline mode
n_free_test = len(freeParams)
n_free_src = len(self.freePars(srcName))
n_free_base = n_free_test - n_free_src
logLike1 = -self()
self._ts_src = []
for comp in self.components:
comp._ts_src = comp.logLike.deleteSource(srcName)
self._ts_src.append(comp._ts_src)
logLike0 = -self()
if tol is None:
tol = self.tol
if reoptimize and n_free_base > 0:
if verbosity > 0:
print "** Do reoptimize"
optFactory = pyLike.OptimizerFactory_instance()
myOpt = optFactory.create(self.optimizer, self.composite)
Niter = 1
while Niter <= MaxIterations:
try:
myOpt.find_min(0, tol)
break
except RuntimeError, e:
print e
if verbosity > 0:
print "** Iteration :", Niter
Niter += 1
