def model_fit_lsb(sed_data, my_shape, plot=True):
from jetset.minimizer import fit_SED, ModelMinimizer
from jetset.model_manager import FitModel
from jetset.jet_model import Jet
jet_lsb = Jet.load_model('prefit_jet_gal_templ.pkl')
jet_lsb.set_gamma_grid_size(200)
fit_model_lsb = FitModel(jet=jet_lsb,
name='SSC-best-fit-lsb',
template=my_shape.host_gal)
fit_model_lsb.freeze('jet_leptonic', 'z_cosm')
fit_model_lsb.freeze('jet_leptonic', 'R_H')
fit_model_lsb.jet_leptonic.parameters.beam_obj.fit_range = [5, 50]
fit_model_lsb.jet_leptonic.parameters.R.fit_range = [10**15.5, 10**17.5]
fit_model_lsb.jet_leptonic.parameters.gmax.fit_range = [1E4, 1E8]
fit_model_lsb.host_galaxy.parameters.nuFnu_p_host.frozen = False
fit_model_lsb.host_galaxy.parameters.nu_scale.frozen = True
model_minimizer_lsb, best_fit_lsb = fit_SED(fit_model_lsb,
sed_data,
10.0**11,
10**29.0,
fitname='SSC-best-fit-lsb',
minimizer='lsb')
best_fit_lsb.save_report('best-fit-minuit-report.txt')
fit_model_lsb.save_model('fit_model_lsb.pkl')
fit_model_lsb_new = FitModel.load_model('fit_model_lsb.pkl')
model_minimizer_lsb.save_model('model_minimizer_lsb.pkl')
model_minimizer_lsb_new = ModelMinimizer.load_model(
'model_minimizer_lsb.pkl')
return jet_lsb, model_minimizer_lsb_new, fit_model_lsb_new
def model_fit_minuit(sed_data, my_shape, plot=True):
from jetset.minimizer import fit_SED
from jetset.model_manager import FitModel
from jetset.jet_model import Jet
jet_minuit = Jet.load_model('prefit_jet_gal_templ.pkl')
jet_minuit.set_gamma_grid_size(200)
fit_model_minuit = FitModel(jet=jet_minuit,
name='SSC-best-fit-minuit',
template=my_shape.host_gal)
fit_model_minuit.freeze('z_cosm')
fit_model_minuit.freeze('R_H')
fit_model_minuit.jet_leptonic.parameters.beam_obj.fit_range = [5, 50]
fit_model_minuit.jet_leptonic.parameters.R.fit_range = [10**15.5, 10**17.5]
fit_model_minuit.host_galaxy.parameters.nuFnu_p_host.frozen = False
fit_model_minuit.host_galaxy.parameters.nu_scale.frozen = True
model_minimizer_minuit, best_fit_minuit = fit_SED(
fit_model_minuit,
sed_data,
10.0**11,
10**29.0,
fitname='SSC-best-fit-minuit',
minimizer='minuit')
best_fit_minuit.save_report('best-fit-minuit-report.txt')
fit_model_minuit.save_model('fit_model_minuit.pkl')
return jet_minuit, model_minimizer_minuit
def test_dep_par_jet(plot=False):
import numpy as np
from jetset.jet_model import Jet
j = Jet(emitters_distribution='plc')
j.add_user_par(name='B0',units='G',val=1E-5,val_min=0,val_max=None)
j.make_dependent_par(par='B',depends_on=['B0'],par_expr='B0*5')
np.testing.assert_allclose(j.parameters.B.val, j.parameters.B0.val*5)
j.save_model('test.pkl')
new_j=Jet.load_model('test.pkl')
new_j.parameters.B0.val=1
np.testing.assert_allclose(new_j.parameters.B.val, new_j.parameters.B0.val*5)
def test_custom_emitters(plot=True):
from jetset.jet_model import Jet
from jetset.jet_emitters import EmittersDistribution
import numpy as np
def distr_func_bkn(gamma_break, gamma, s1, s2):
return np.power(gamma, -s1) * (1. +
(gamma / gamma_break))**(-(s2 - s1))
n_e = EmittersDistribution('custom_bkn', spectral_type='bkn')
n_e.add_par('gamma_break',
par_type='turn-over-energy',
val=1E3,
vmin=1.,
vmax=None,
unit='lorentz-factor')
n_e.add_par('s1',
par_type='LE_spectral_slope',
val=2.5,
vmin=-10.,
vmax=10,
unit='')
n_e.add_par('s2',
par_type='LE_spectral_slope',
val=3.2,
vmin=-10.,
vmax=10,
unit='')
n_e.set_distr_func(distr_func_bkn)
n_e.parameters.show_pars()
n_e.parameters.s1.val = 2.0
n_e.parameters.s2.val = 3.5
if plot is True:
n_e.plot()
my_jet = Jet(emitters_distribution=n_e)
my_jet.Norm_distr = True
my_jet.parameters.N.val = 5E4
my_jet.eval()
np.testing.assert_allclose(my_jet.emitters_distribution.eval_N(),
my_jet.parameters.N.val,
rtol=1E-5)
print(my_jet.emitters_distribution.eval_N(), my_jet.parameters.N.val)
print(n_e.eval_N(), my_jet.parameters.N.val)
assert (my_jet.emitters_distribution.emitters_type == 'electrons')
my_jet.save_model('test_jet_custom_emitters.pkl')
my_jet = Jet.load_model('test_jet_custom_emitters.pkl')
my_jet.eval()
def test_jet(plot=True):
#print('--------> plot',plot)
from jetset.jet_model import Jet
j = Jet()
j.eval()
j.energetic_report()
if plot is True:
j.plot_model()
j.emitters_distribution.plot()
j.emitters_distribution.plot2p()
j.emitters_distribution.plot3p()
j.emitters_distribution.plot3p(energy_unit='eV')
j.emitters_distribution.plot3p(energy_unit='erg')
j.save_model('test_jet.pkl')
j_new = Jet.load_model('test_jet.pkl')
def test_custom_emitters_array(plot=True):
from jetset.jet_model import Jet
from jetset.jet_emitters import EmittersArrayDistribution
import numpy as np
# gamma array
gamma = np.logspace(1, 8, 500)
# gamma array this is n(\gamma) in 1/cm^3/gamma
n_gamma = gamma**-2 * 1E-5 * np.exp(-gamma / 1E5)
N1 = np.trapz(n_gamma, gamma)
n_distr = EmittersArrayDistribution(name='array_distr',
emitters_type='protons',
gamma_array=gamma,
n_gamma_array=n_gamma,
normalize=False)
N2 = np.trapz(n_distr._array_n_gamma, n_distr._array_gamma)
j = Jet(emitters_distribution=n_distr, verbose=False)
j.parameters.z_cosm.val = z = 0.001
j.parameters.beam_obj.val = 1
j.parameters.N.val = 1
j.parameters.NH_pp.val = 1
j.parameters.B.val = 0.01
j.parameters.R.val = 1E18
j.set_IC_nu_size(100)
j.gamma_grid_size = 200
N3 = np.trapz(j.emitters_distribution.n_gamma_p,
j.emitters_distribution.gamma_p)
np.testing.assert_allclose(N1, N2, rtol=1E-5)
np.testing.assert_allclose(N1, N3, rtol=1E-2)
np.testing.assert_allclose(N1, j.emitters_distribution.eval_N(), rtol=1E-2)
assert (j.emitters_distribution.emitters_type == 'protons')
j.eval()
j.save_model('test_jet_custom_emitters_array.pkl')
j = Jet.load_model('test_jet_custom_emitters_array.pkl')
j.eval()
def test_jet(plot=True):
print('--------> test_jet', plot)
from jetset.jet_model import Jet
j = Jet()
j.eval()
j.energetic_report()
sum1 = j.spectral_components.Sum.SED.nuFnu
if plot is True:
j.plot_model()
j.emitters_distribution.plot()
j.emitters_distribution.plot2p()
j.emitters_distribution.plot3p()
j.emitters_distribution.plot3p(energy_unit='eV')
j.emitters_distribution.plot3p(energy_unit='erg')
j.save_model('test_jet.pkl')
j_new = Jet.load_model('test_jet.pkl')
j_new.eval()
sum2 = j_new.spectral_components.Sum.SED.nuFnu
np.testing.assert_allclose(sum2, sum1, rtol=1E-5)
def test_prepare_fit(sed_data=None, prefit_jet=None, plot=True,sed_number=1):
from jetset.jet_model import Jet
if sed_data is None:
from .test_data import test_data_loader
sed_data = test_data_loader(plot=plot, sed_number=sed_number)
if prefit_jet is None:
from .test_phenom_constr import test_model_constr
prefit_jet, my_shape = test_model_constr(sed_data=sed_data)
if hasattr(my_shape, 'host_gal'):
template = my_shape.host_gal
else:
template = None
jet = Jet.load_model('prefit_jet.pkl')
jet.set_gamma_grid_size(200)
return template,jet,sed_data
def test_hadronic_jet(plot=True):
from jetset.jet_model import Jet
j = Jet(proton_distribution='plc')
j.parameters.gmin.val = 2
j.parameters.gmax.val = 1E8
j.parameters.NH_pp.val = 1E10
j.parameters.N.val = 1E1
j.parameters.B.val = 80
j.parameters.p.val = 2.5
j.eval()
j.show_model()
sum1 = j.spectral_components.Sum.SED.nuFnu
if plot is True:
j.plot_model()
j.save_model('test_jet_hadronic.pkl')
j_new = Jet.load_model('test_jet_hadronic.pkl')
j_new.eval()
sum2 = j_new.spectral_components.Sum.SED.nuFnu
np.testing.assert_allclose(sum2, sum1, rtol=1E-5)
def model_fit_lsb(sed_data, ):
from jetset.minimizer import fit_SED
from jetset.model_manager import FitModel
from jetset.jet_model import Jet
jet = Jet.load_model('prefit_jet.dat')
fit_model = FitModel(jet=jet, name='SSC-best-fit', template=None)
fit_model.freeze('z_cosm')
fit_model.freeze('R_H')
fit_model.parameters.R.fit_range = [10**15.5, 10**17.5]
fit_model.parameters.gmax.fit_range = [1E4, 1E8]
model_minimizer_lsb, best_fit_lsb = fit_SED(fit_model,
sed_data,
10.0**11,
10**29.0,
fitname='SSC-best-fit',
minimizer='lsb')
best_fit_lsb.save_report('best-fit-lsb-report.txt')
fit_model.save_model('fit_model_lsb.dat')
def test_dep_par(plot=False):
from jetset.jet_emitters import EmittersDistribution
import numpy as np
def distr_func_bkn(gamma_break, gamma, s1, s2):
return np.power(gamma, -s1) * (1. + (gamma / gamma_break)) ** (-(s2 - s1))
n_e_bkn = EmittersDistribution('bkn', spectral_type='bkn')
n_e_bkn.add_par('gamma_break', par_type='turn-over-energy', val=1E3, vmin=1., vmax=None, unit='lorentz-factor')
n_e_bkn.add_par('s1', par_type='LE_spectral_slope', val=2.5, vmin=-10., vmax=10, unit='')
n_e_bkn.add_par('s2', par_type='LE_spectral_slope', val=3.2, vmin=-10., vmax=10, unit='')
n_e_bkn.set_distr_func(distr_func_bkn)
n_e_bkn.parameters.show_pars()
n_e_bkn.parameters.s1.val = 2.0
n_e_bkn.parameters.s2.val = 3.5
n_e_bkn.update()
n_e_bkn.parameters.show_pars()
from jetset.jet_model import Jet
j = Jet(emitters_distribution=n_e_bkn)
# def par_func(s1):
# return s1+1
j.make_dependent_par(par='s2', depends_on=['s1'], par_expr='s1+1')
print('here')
j.parameters.s1.val = 3
print('done')
np.testing.assert_allclose(j.parameters.s2.val, j.parameters.s1.val + 1)
j.save_model('jet.pkl')
new_jet = Jet.load_model('jet.pkl')
print('here')
new_jet.parameters.s1.val = 2
print('done')
np.testing.assert_allclose(new_jet.parameters.s2.val, new_jet.parameters.s1.val + 1)
j.eval()
new_jet.show_model()