def make_x_plot():
energy_min = np.array([300])
energy_max = np.array([1000])
energies = np.array(_energy_lafferty_power_law(energy_min, energy_max,
SPECTRAL_INDEX))
diff_flux = power_law_evaluate(energies, 1, SPECTRAL_INDEX, 1)
# `True' differential & integral fluxes
int_flux = power_law_integral_flux(diff_flux, SPECTRAL_INDEX,
energies, energy_min, energy_max)
# Put data into table
table = Table()
table['ENERGY_MIN'] = energy_min
table['ENERGY_MAX'] = energy_max
table['INT_FLUX'] = int_flux
lafferty_array = []
log_array = []
spectral_indices = np.arange(1.1, 6, 0.01)
for spectral_index in spectral_indices:
lafferty_flux, log_flux = get_flux_tables(table, 'power_law', None,
spectral_index)
dlog_energy = np.log(energy_max) - np.log(energy_min)
residuals_lafferty = np.log(lafferty_flux['ENERGY'] - np.log(energy_min)) / dlog_energy
residuals_log = np.log(log_flux['ENERGY'] - np.log(energy_min)) / dlog_energy
lafferty_array.append(residuals_lafferty[0])
log_array.append(residuals_log[0])
plt.plot(spectral_indices, lafferty_array,
linewidth=1, ms=0, label='Lafferty Method')
plt.plot(spectral_indices, log_array,
linewidth=1, ms=0, label='Log Center Method')
plt.legend()
plt.ylabel('X position in bin')
plt.xlabel('Guessed spectral Index')
def make_x_plot():
energy_min = np.array([300])
energy_max = np.array([1000])
energies = np.array(_energy_lafferty_power_law(energy_min, energy_max,
SPECTRAL_INDEX))
diff_flux = power_law_evaluate(energies, 1, SPECTRAL_INDEX, 1)
# `True' differential & integral fluxes
int_flux = power_law_integral_flux(diff_flux, SPECTRAL_INDEX,
energies, energy_min, energy_max)
# Put data into table
table = Table()
table['ENERGY_MIN'] = energy_min
table['ENERGY_MAX'] = energy_max
table['INT_FLUX'] = int_flux
lafferty_array = []
log_array = []
spectral_indices = np.arange(1.1, 6, 0.01)
for spectral_index in spectral_indices:
lafferty_flux, log_flux = get_flux_tables(table, 'power_law', None,
spectral_index)
dlog_energy = np.log(energy_max) - np.log(energy_min)
residuals_lafferty = np.log(lafferty_flux['ENERGY'] - np.log(energy_min)) / dlog_energy
residuals_log = np.log(log_flux['ENERGY'] - np.log(energy_min)) / dlog_energy
lafferty_array.append(residuals_lafferty[0])
log_array.append(residuals_log[0])
plt.plot(spectral_indices, lafferty_array,
linewidth=1, ms=0, label='Lafferty Method')
plt.plot(spectral_indices, log_array,
linewidth=1, ms=0, label='Log Center Method')
plt.legend()
plt.ylabel('X position in bin')
plt.xlabel('Guessed spectral Index')
def compute_flux_error(gamma_true, gamma_reco, method):
# Let's assume a concrete true spectrum and energy bin.
# Note that the residuals computed below do *not* depend on
# these parameters.
energy_min, energy_max = 1, 10
energy_ref, diff_flux_ref = 1, 1
# Compute integral flux in the energy band assuming `gamma_true`
int_flux = power_law_integral_flux(diff_flux_ref, gamma_true, energy_ref,
energy_min, energy_max)
# Compute flux point
table = compute_differential_flux_points(method,
'power_law',
spectral_index=gamma_reco,
energy_min=energy_min,
energy_max=energy_max,
int_flux=int_flux)
# Compute relative error of the flux point
energy = table['ENERGY'].data
flux_reco = table['DIFF_FLUX'].data
flux_true = power_law_evaluate(energy,
diff_flux_ref * np.ones_like(energy),
np.array(gamma_true).reshape(energy.shape),
energy_ref * np.ones_like(energy))
flux_true = flux_true.reshape(gamma_true.shape)
flux_reco = flux_reco.reshape(gamma_true.shape)
flux_error = (flux_reco - flux_true) / flux_true
return flux_error
def plot_power_law():
# Define the function
x = np.arange(0.1, 100000, 0.1)
spectral_model = my_spectrum(x)
spectral_model_function = lambda x: my_spectrum(x)
y = spectral_model
# Set the x-bins
energy_min = [0.1, 1, 10, 100, 1000]
energy_max = [1, 10, 100, 1000, 10000]
energies = np.array(_x_lafferty(energy_min, energy_max,
spectral_model_function))
diff_fluxes = spectral_model_function(energies)
indices = np.array([0, 1, 2, 3, 4])
int_flux = power_law_integral_flux(diff_fluxes, (indices + 1),
energies, energy_min, energy_max)
special = lambda x: np.log(x)
int_flux[0] = np.abs(_integrate([energy_min[0]],
[energy_max[0]], special)[0])
# Put data into table
table = Table()
table['ENERGY_MIN'] = energy_min
table['ENERGY_MAX'] = energy_max
table['INT_FLUX'] = int_flux
plot_flux_points(table, x, y, spectral_model_function,
energy_min, 'power_law')
plt.tight_layout()
plt.legend()
def plot_power_law():
# Define the function
x = np.arange(0.1, 100000, 0.1)
spectral_model = my_spectrum(x)
spectral_model_function = lambda x: my_spectrum(x)
y = spectral_model
# Set the x-bins
energy_min = [0.1, 1, 10, 100, 1000]
energy_max = [1, 10, 100, 1000, 10000]
energies = np.array(
_x_lafferty(energy_min, energy_max, spectral_model_function))
diff_fluxes = spectral_model_function(energies)
indices = np.array([0, 1, 2, 3, 4])
int_flux = power_law_integral_flux(diff_fluxes, (indices + 1), energies,
energy_min, energy_max)
special = lambda x: np.log(x)
int_flux[0] = np.abs(
_integrate([energy_min[0]], [energy_max[0]], special)[0])
# Put data into table
table = Table()
table['ENERGY_MIN'] = energy_min
table['ENERGY_MAX'] = energy_max
table['INT_FLUX'] = int_flux
plot_flux_points(table, x, y, spectral_model_function, energy_min,
'power_law')
plt.tight_layout()
plt.legend()
def compute_flux_error(gamma_true, gamma_reco, method):
# Let's assume a concrete true spectrum and energy bin.
# Note that the residuals computed below do *not* depend on
# these parameters.
energy_min, energy_max = 1, 10
energy_ref, diff_flux_ref = 1, 1
# Compute integral flux in the energy band assuming `gamma_true`
int_flux = power_law_integral_flux(diff_flux_ref, gamma_true,
energy_ref, energy_min, energy_max)
# Compute flux point
table = compute_differential_flux_points(method, 'power_law',
spectral_index=gamma_reco,
energy_min=energy_min, energy_max=energy_max,
int_flux=int_flux)
# Compute relative error of the flux point
energy = table['ENERGY'].data
flux_reco = table['DIFF_FLUX'].data
flux_true = power_law_evaluate(energy, diff_flux_ref * np.ones_like(energy),
np.array(gamma_true).reshape(energy.shape),
energy_ref * np.ones_like(energy))
flux_true = flux_true.reshape(gamma_true.shape)
flux_reco = flux_reco.reshape(gamma_true.shape)
flux_error = (flux_reco - flux_true) / flux_true
return flux_error