def plot_all_Stern(ax):
plot_Stern(run, ax)
sternfile2 = '/nethome/palmerio/1ere_annee/Frederic/GRB_population_code/observational_constraints/Stern_binning/Stern_digitized.csv'
mid_bins_digi = pf.read_column(sternfile2, 0, splitter=', ') / 0.75
stern_digi = pf.read_column(sternfile2, 1, splitter=', ')
stern22 = '/nethome/palmerio/1ere_annee/Frederic/GRB_population_code/observational_constraints/Stern_binning/Value.csv'
mid_bins_digi2 = pf.read_column(stern22, 0, splitter=', ') / 0.75
stern_digi2 = pf.read_column(stern22, 1, splitter=', ')
stern22errp = '/nethome/palmerio/1ere_annee/Frederic/GRB_population_code/observational_constraints/Stern_binning/Errors plus.csv'
mid_bins_digi2errp = pf.read_column(stern22errp, 0, splitter=', ') / 0.75
stern_digi2errp = pf.read_column(stern22errp, 1, splitter=', ')
stern22errm = '/nethome/palmerio/1ere_annee/Frederic/GRB_population_code/observational_constraints/Stern_binning/Errors minus.csv'
mid_bins_digi2errm = pf.read_column(stern22errm, 0, splitter=', ') / 0.75
stern_digi2errm = pf.read_column(stern22errm, 1, splitter=', ')
ax.scatter(mid_bins_digi2errp, stern_digi2errp, marker='s', color='r')
ax.scatter(mid_bins_digi2errm, stern_digi2errm, marker='s', color='b')
ax.scatter(mid_bins_digi2, stern_digi2, marker='+', color='k')
ax.scatter(mid_bins_digi, stern_digi, marker='x', color='darkorange')
ax.errorbar(bins_middle,
hist_Stern,
yerr=hist_Stern_err,
color='g',
fmt='.')
ax.scatter(bins_middle,
hist_Stern,
color='g',
alpha=0.6,
marker='D',
label='Constraint from Daigne+06')
return
def create_hist(filename, n_col, bins=40, ax=None, **kwargs):
data = pf.read_column(filename, n_col, splitter='|', stripper='|')
data_mask = np.isfinite(data)
data = data[data_mask]
if ax is not None:
ax.hist(data, bins=bins, **kwargs)
else:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(data, bins=bins, **kwargs)
return
def plot_Stern(run,
ax,
label='Model',
obs_leg=1,
post_process_mode=False,
N_constraint=6,
**kwargs):
"""
Function that plots Stern constraint onto the provided ax.
If post_process_mode is True, it will average with weights equal to the inverse of the Chi2,
So that models with high Chi2 have lower weight.
"""
file_Stern = root_dir + run + '/Stern_constraint.dat'
file_Stern_err = root_dir + run + '/Stern_constrainterr.dat'
P23_Stern = pf.read_column(file_Stern, 0)
LogN_Stern_obs = pf.read_column(file_Stern, 2)
P23_Stern_av = pf.read_column(file_Stern_err, 0)
LogN_Stern_obs_av = pf.read_column(file_Stern_err, 3)
LogN_Stern_obs_av_err = pf.read_column(file_Stern_err, 4)
## Small code for the errorbars to work on logscale ###
LogN_Stern_errp = LogN_Stern_obs_av * (10**LogN_Stern_obs_av_err - 1.)
LogN_Stern_errm = LogN_Stern_obs_av * (1. - 10**(-LogN_Stern_obs_av_err))
P23_Stern_err = np.zeros(len(P23_Stern_av))
for i in range(len(P23_Stern_av)):
j = 2 * i
P23_Stern_err[i] = np.log10(P23_Stern[j + 1] / P23_Stern_av[i])
P23_Stern_errp = P23_Stern_av * (10**P23_Stern_err - 1.)
P23_Stern_errm = P23_Stern_av * (1. - 10**(-P23_Stern_err))
if obs_leg == 1:
ax.errorbar(P23_Stern_av,
LogN_Stern_obs_av,
xerr=[P23_Stern_errm, P23_Stern_errp],
yerr=[LogN_Stern_errm, LogN_Stern_errp],
markersize=5,
marker='s',
capsize=0,
label='Stern+01',
fmt='.',
color='k') #,color=plt.rcParams['axes.color_cycle'][0])
else:
ax.errorbar(P23_Stern_av,
LogN_Stern_obs_av,
xerr=[P23_Stern_errm, P23_Stern_errp],
yerr=[LogN_Stern_errm, LogN_Stern_errp],
markersize=5,
marker='s',
capsize=0,
fmt='.',
color='k') #,color=plt.rcParams['axes.color_cycle'][0])
if post_process_mode is False:
LogN_Stern_mod = pf.read_column(file_Stern, 1)
LogN_Stern_mod_av = pf.read_column(file_Stern_err, 1)
LogN_Stern_mod_av_err = pf.read_column(file_Stern_err, 2)
ax.plot(P23_Stern, LogN_Stern_mod, label=label, lw=1.5, **kwargs)
#ax.errorbar(P23_Stern_av, LogN_Stern_mod_av, yerr=LogN_Stern_mod_av_err,fmt='.', capsize=0,color='k')#plt.rcParams['axes.color_cycle'][color])
else:
# read data
file_Stern_post_proc = root_dir + run + '/Stern_constraint_post_proc.dat'
data = np.genfromtxt(file_Stern_post_proc, dtype=None)
n_lines = len(data)
print("Post-processed {} models".format(n_lines))
data = np.transpose(data)
n_bins = len(data) - (
N_constraint + 1) #because of the size of chi2 array from f90 code
Chi2_array = data[0]
LogN_Stern_hist_mod_med = np.zeros(2 * n_bins)
LogN_Stern_hist_mod_std = np.zeros(2 * n_bins)
for i in range(n_bins):
LogN_Stern_hist_mod_med[2 * i] = np.average(data[i + 1 +
N_constraint],
weights=data[0]**(-1))
LogN_Stern_hist_mod_med[2 * i + 1] = LogN_Stern_hist_mod_med[2 * i]
LogN_Stern_hist_mod_std[2 * i] = np.std(data[i + 1 + N_constraint])
LogN_Stern_hist_mod_std[2 * i + 1] = LogN_Stern_hist_mod_std[2 * i]
# plot it
ax.plot(P23_Stern,
LogN_Stern_hist_mod_med,
lw='2',
label=label,
**kwargs)
ax.fill_between(P23_Stern,
LogN_Stern_hist_mod_med - LogN_Stern_hist_mod_std,
LogN_Stern_hist_mod_med + LogN_Stern_hist_mod_std,
alpha=0.3,
**kwargs)
ax.set_title('Intensity Constraint', **font)
ax.set_xlabel(r'Peak flux $\mathrm{[ph\,cm^{-2}\,s^{-1}\,50-300\,keV]}$',
**font)
ax.set_ylabel(
r' $\Delta N/\Delta \,(\mathrm{log\,}P)\,\mathrm{[yr^{-1}]}$ ', **font)
ax.set_xlim([0.05, 150.])
ax.set_xscale('log')
ax.set_yscale('log')
leg = ax.legend(loc='best', numpoints=1)
leg.get_frame().set_edgecolor('k')
return
T_min = 2.05 # secondes
P23_min = 0.01 # ph/cm2/s
N_bin_min = 1 # Nb of bins with flx >= 50% of pflx -> more robust than T90>2s because of uncertainties on T90 measurement (see Stern+01)
verbose = 1
file_Stern = str(
root_dir /
'GRB_population_model/observational_constraints/lognlogp.stern.dat')
text_size = 22
font = {'fontname': 'Serif', 'size': text_size}
run = '170704_Amati_zevol'
#################### Stern #######################
filename_S = 'Stern_cat.txt'
name_S = pf.read_column(filename_S, 0, dtype=str, splitter='\t')
T90_S = pf.read_column(filename_S, 7, splitter='\t')
N_bin_S = pf.read_column(filename_S, 8, splitter='\t')
peak_flux_1024_S = pf.read_column(filename_S, 3, splitter='\t')
peak_flux_1024_mask_S = np.isfinite(peak_flux_1024_S)
final_peak_flux_1024_S = peak_flux_1024_S[peak_flux_1024_mask_S]
final_long_peak_flux_1024_S = peak_flux_1024_S[N_bin_S > N_bin_min]
# Stern
bins = pf.read_column(file_Stern, 0, array=False)
hist_Stern = 10**pf.read_column(file_Stern, 1)
hist_Stern_err = 10**pf.read_column(file_Stern, 2)
bins.append(1.8)
bins = 10**np.asarray(bins) / 0.75
bins_middle = np.zeros(len(bins) - 1)
bins_errp = np.zeros(len(bins_middle))
# To allow the importation of plotting function module anywhere
import sys
import platform
if platform.system() == 'Linux':
sys.path.insert(0, '/nethome/palmerio/Dropbox/Plotting_GUI/Src')
elif platform.system() == 'Darwin':
sys.path.insert(0, '/Users/palmerio/Dropbox/Plotting_GUI/Src')
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import plotting_functions as pf
root_dir = '/nethome/palmerio/1ere_annee/Frederic/catalogs/BAT6_cat/'
filename = root_dir + 'BAT6ext_GRB_formation_rate.txt'
outputfilename = root_dir + 'z_cumul_distr_Pesc16.txt'
z = pf.read_column(filename, 0)
distr = pf.read_column(filename, 1)
distr_err = pf.read_column(filename, 2)
plt.errorbar(z, distr, yerr=distr_err, fmt='.')
plt.show()
plt.style.use('presentation')
matplotlib.rc('text', usetex=True)
matplotlib.rc('font',**{'family':'serif','serif':['Palatino']})
T_min = 2.05 # secondes
P23_min = 0.01 # ph/cm2/s
filename = 'GBM_cat_complete.txt'
# Print the content of the catalog
overhead = pf.read_overhead(filename, splitter='|', stripper='|')
print len(overhead)
for i in range(len(overhead)):
print i, overhead[i]
name = pf.read_column(filename, 0, dtype=str, stripper='|', splitter = '|')
# T90
T90 = pf.read_column(filename, 1, stripper='|', splitter = '|')
T90_mask = np.isfinite(T90)
# pflx
peak_flux_1024 = pf.read_column(filename, 34, stripper='|', splitter = '|' )
peak_flux_1024_err = pf.read_column(filename, 35, stripper='|', splitter = '|' )
peak_flux_1024_mask = np.isfinite(peak_flux_1024)
# Band spectrum at pflx
nd_pflx_band_ampl = pf.read_data(filename, 79, stripper='|', splitter = '|')
nd_pflx_band_epeak = pf.read_data(filename, 82, stripper='|', splitter = '|')
nd_pflx_band_alpha = pf.read_data(filename, 85, stripper='|', splitter = '|')
nd_pflx_band_beta = pf.read_data(filename, 88, stripper='|', splitter = '|')
vmax=colormap[2]) # limits to the colorbar if colormap is used
scatterplot = ax.scatter(x_to_plot,
y_to_plot,
c=colormap[0][x_mask & y_mask],
cmap=colormap[3],
norm=norm,
**kwargs)
else:
scatterplot = ax.scatter(x_to_plot, y_to_plot, **kwargs)
return scatterplot
# Create original BAT6
filename_og = root_dir + 'catalogs/BAT6_cat/BAT6_2012.txt'
name_og = pf.read_column(filename_og, 0, dtype=str, splitter='\t|')
redshift_og = pf.read_column(filename_og, 1, dtype=float, splitter='\t|')
redshift_og_mask = np.isfinite(redshift_og)
obs_redshift_og_masked = np.zeros(len(redshift_og))
# Extended BAT6 : eBAT6
file_eBAT6_obs = root_dir + 'catalogs/BAT6_cat/eBAT6_cat.txt'
obs_name = pf.read_column(file_eBAT6_obs,
0,
stripper='|',
splitter='|',
dtype=str)
obs_redshift = pf.read_column(file_eBAT6_obs, 1, stripper='|', splitter='|')
obs_redshift2 = pf.read_data(file_eBAT6_obs, 1, stripper='|', splitter='|')
obs_redshift_mask = np.isfinite(obs_redshift)
obs_redshift_masked = np.zeros(len(obs_redshift))
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
import plotting_functions as pf
#from astroML.plotting import hist
from scipy.stats import chi2
from scipy import interpolate
filename = '/nethome/palmerio/1ere_annee/Frederic/catalogs/BAT6_cat/eBAT6_cat.txt'
overhead = pf.read_overhead(filename, splitter='|', stripper='|')
for i in range(len(overhead)):
print i, overhead[i]
name = pf.read_column(filename, 0, dtype=str, stripper='|', splitter='|')
redshift = pf.read_column(filename, 1, stripper='|', splitter='|')
Ep = pf.read_column(filename, 13, stripper='|', splitter='|')
Ep_err = pf.read_column(filename, 14, stripper='|', splitter='|')
Lum = pf.read_column(filename, 15, stripper='|', splitter='|')
Lum_err = pf.read_column(filename, 16, stripper='|', splitter='|')
redshift_mask = np.isfinite(redshift)
Ep_mask = np.isfinite(Ep)
Lum_mask = np.isfinite(Lum)
redshift_masked = redshift[redshift_mask]
Ep_masked = []
for i in range(len(Ep[Ep_mask])):
if Ep[Ep_mask][i] >= 0:
Ep_masked.append(Ep[Ep_mask][i])
if platform.system() == 'Linux':
sys.path.insert(0, '/nethome/palmerio/Dropbox/Plotting_GUI/Src')
elif platform.system() == 'Darwin':
sys.path.insert(0, '/Users/palmerio/Dropbox/Plotting_GUI/Src')
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import plotting_functions as pf
from astroML.plotting import hist
#import seaborn as sns
import scipy as sp
root_dir = '/nethome/palmerio/1ere_annee/Frederic/'
filename = root_dir + 'catalogs/BAT6_cat/BAT6_2012.txt'
name = pf.read_column(filename, 0, dtype=str, splitter='\t|')
redshift = pf.read_column(filename, 1, dtype=float, splitter='\t|')
RA = pf.read_column(filename, 2, dtype=str, splitter='\t|')
dec = pf.read_column(filename, 3, dtype=str, splitter='\t|')
j = 0
redshift_lim = 2
print "Original BAT6 sample (Salvaterra et al. 2012) northern (dec >= 30 degrees) GRBs :"
print "Redshift cut applied : %.3lf" % redshift_lim
print "no \t name \t redshift \t RA \t dec"
for i in range(len(name)):
if float(dec[i][:3]) >= 30:
if redshift[i] <= redshift_lim:
j += 1
print "%2d \t %s \t %.4lf \t %s \t %s" % (j, name[i], redshift[i],
RA[i], dec[i])
f.write("%s\t %6.4lf\n" % (name_final[-1], redshift_final[-1]))
f.close()
return
# Swift data
filename = homedir + 'catalogs/Swift_cat/Swift_redshift_cleaned_table.txt'
data = pd.read_csv(filename, delimiter='\t', skiprows=1)
Swift_name = data.values.transpose()[0]
Swift_redshift = data.values.transpose()[1]
# eBAT6 data
filename = homedir + 'catalogs/BAT6_cat/eBAT6_cat.txt'
eBAT6_name = pf.read_column(filename,
0,
dtype=str,
splitter='\t|',
stripper='|')
eBAT6_redshift = pf.read_column(filename, 1, splitter='\t|', stripper='|')
eBAT6_redshift_masked = eBAT6_redshift[np.isfinite(eBAT6_redshift)]
fig = plt.figure(tight_layout=True, figsize=(10, 8))
ax = fig.add_subplot(111)
pf.ks_and_plot(ax,
Swift_redshift,
eBAT6_redshift_masked,
labels=['Swift', 'eBAT6'],
lw=2)
#Swift_redshift_for_ECDF, ECDF_Swift = pf.unbinned_empirical_cdf(Swift_redshift)
import matplotlib.pyplot as plt
import pandas as pd
#import statsmodels.api as sm
"""
See GBM_cat_cutoff.py for the real logNlogP figure
"""
#plt.style.use('ggplot')
homedir = '/nethome/palmerio/1ere_annee/Frederic/'
text_size = 22
font = {'fontname': 'Serif', 'size': text_size}
# Swift data
filename = homedir + 'catalogs/Swift_cat/Swift_pflx_cat.txt'
Swift_name = pf.read_column(filename, 0, dtype=str)
Swift_pflx = pf.read_column(filename, 1)
Swift_pflx_err = pf.read_column(filename, 2)
Swift_pflx_masked = Swift_pflx[np.isfinite(Swift_pflx)]
Swift_pflx_err_masked = Swift_pflx_err[np.isfinite(Swift_pflx_err)]
print "min, max, median : ", min(Swift_pflx_masked), max(
Swift_pflx_masked), np.median(Swift_pflx_masked)
fig = plt.figure(tight_layout=True, figsize=(10, 8))
ax = fig.add_subplot(111)
_unused, bins_logscale = np.histogram(np.log10(Swift_pflx_masked), bins=20)
ax.hist(Swift_pflx_masked,
bins=10**bins_logscale,
color='darkorange',
label='Swift peak flux distribution')
alpha=0.9,
alpha_errorbar=0.1,
s=50,
label='All')
#axa.set_yscale('log')
axa.set_xscale('log')
axb.set_yscale('log')
#plt.show()
overhead = pf.read_overhead(filename, splitter='|', stripper='|')
print len(overhead)
for i in range(len(overhead)):
print i, overhead[i]
#raise SystemExit
name = pf.read_column(filename, 0, dtype=str, stripper='|', splitter='|')
T90 = pf.read_column(filename, 1, stripper='|', splitter='|')
T90_mask = np.isfinite(T90)
peak_flux_1024 = pf.read_column(filename, 34, stripper='|',
splitter='|') # Batse flux (50-300 keV)
peak_flux_1024_err = pf.read_column(filename, 35, stripper='|',
splitter='|') # Batse flux (50-300 keV)
peak_flux_1024_mask = np.isfinite(peak_flux_1024)
T90_masked = T90[T90_mask & peak_flux_1024_mask]
peak_flux_1024_masked = peak_flux_1024[T90_mask & peak_flux_1024_mask]
print 'N_GRB avant coupure : ', len(peak_flux_1024_masked)
peak_flux_1024_timecut = peak_flux_1024_masked[T90_masked >= 2.]
import seaborn as sns
import pandas as pd
plt.style.use('default')
plt.style.use('ggplot')
root_dir = '/nethome/palmerio/1ere_annee/Frederic/GRB_population_code/observational_constraints/'
text_size = 22
font = {'fontname': 'Serif', 'size': text_size}
colors = pf.generate_colors()
file1 = root_dir + 'Preece_histo.ep.dat'
file2 = root_dir + 'Preece_histo.eb.dat'
file_og = root_dir + 'preece.eb.dat'
Ep_og = pf.read_column(file_og, 0)
pk_og = pf.read_column(file_og, 1)
Ep = pf.read_column(file1, 0)
pk1_Ep = pf.read_column(file1, 1)
pk2_Ep = pf.read_column(file1, 2)
pk3_Ep = pf.read_column(file1, 3)
pk4_Ep = pf.read_column(file1, 4)
Eb = pf.read_column(file2, 0)
pk1_Eb = pf.read_column(file2, 1)
pk2_Eb = pf.read_column(file2, 2)
pk3_Eb = pf.read_column(file2, 3)
pk4_Eb = pf.read_column(file2, 4)
fig = plt.figure(tight_layout=True, figsize=(10, 10))
def Swift_compare():
fig = plt.figure(tight_layout=True, figsize=(12,10))
ax = fig.add_subplot(211)
ax2 = fig.add_subplot(212, sharex=ax)
file_redshift ='catalogs/Swift_cat/Swift_redshift_cleaned_table.txt'
name_redshift = pf.read_column(file_redshift, 0, dtype=str)
redshift=pf.read_column(file_redshift, 1)
combined_Swift_table = []
for i in range(len(name_redshift)):
for j in range(len(final_name_Sw)):
if final_name_Sw[j] == name_redshift[i]:
combined_Swift_table.append([name_redshift[i], redshift[i], final_peak_flux_1024_Sw[j]])
combined_Swift_table = np.asarray(combined_Swift_table)
combined_name = combined_Swift_table.transpose()[0]
combined_redshift = combined_Swift_table.transpose()[1]
combined_pflx = np.asarray(combined_Swift_table.transpose()[2],dtype=float)
hist_Sw_comb, bins_Sw_comb = np.histogram(combined_pflx, bins=bins)
hist_Sw_comb = np.asarray(hist_Sw_comb, dtype=float)
hist_Sw_comb_err = np.sqrt(hist_Sw_comb)
N_tot_Sw_comb = sum(hist_Sw_comb)
#best_parametre_Sw = chi2_parameter_adjust_logNlogP(hist_Sw,hist_Sw_err,'Swift',min_param=-10, max_param=100, show_plot=True)
#label_Swift = r"Swift [15-150keV] (adjusted : $<\Omega>*\mathrm{T_{utile}} =$%.1e [sr yr])" %(4*np.pi*best_parametre_Sw)
for i in range(len(bins_middle)):
hist_Sw_comb[i] /= np.log10( bins[i+1] / bins[i] )
hist_Sw_comb_err[i] /= np.log10( bins[i+1] / bins[i] )
#hist_Sw_comb /= best_parametre_Sw
#hist_Sw_comb_err /= best_parametre_Sw
ax.errorbar(bins_middle, hist_Sw, xerr=[bins_errm, bins_errp], yerr=hist_Sw_err, marker=None, fmt='.', label='Swift N=%d'%int(N_tot_Sw))
ax.errorbar(bins_middle, hist_Sw_comb, xerr=[bins_errm, bins_errp], yerr=hist_Sw_comb_err, marker=None, fmt='.', label='Swift with redshift N=%d'%int(N_tot_Sw_comb))
ax.set_yscale('log')
ax2.set_xscale('log')
ax.legend(loc='best', numpoints=1)
ax.set_title('1024ms timescale in 15-150 keV band for LGRB Swift catalogs\nuncorrected for useful time.', **font)
ax2.set_xlabel(r'Peak flux $\mathrm{[ph\,cm^{-2}\,s^{-1}\,15-150\,keV]}$', **font)
ax.set_ylabel(r'$\Delta N/\Delta \,(\mathrm{log\,}P)$ ', **font)
ax2.set_ylabel('Fraction of GRBs\ndetected with redshift', **font)
ax.grid()
ax2.grid()
redshift_efficiency = hist_Sw_comb/hist_Sw
redshift_efficiency[np.where(~np.isfinite(redshift_efficiency))]=0
redshift_efficiency_errp = np.zeros(len(redshift_efficiency))
redshift_efficiency_errm = np.zeros(len(redshift_efficiency))
for i in range(len(redshift_efficiency)):
if hist_Sw_comb[i] > 0 and hist_Sw[i] > 0:
redshift_efficiency_errp[i] = np.sqrt((hist_Sw_comb_err[i]/hist_Sw_comb[i])**2 + (hist_Sw_err[i]/hist_Sw[i])**2 )
redshift_efficiency_errm[i] = redshift_efficiency_errp[i]
else :
redshift_efficiency_errp[i] = 0.0
redshift_efficiency_errm[i] = 0.0
if redshift_efficiency[i] + redshift_efficiency_errp[i] >= 1.0:
redshift_efficiency_errp[i] = 1.0 - redshift_efficiency[i]
if redshift_efficiency[i] - redshift_efficiency_errm[i] <= 0.0:
redshift_efficiency_errm[i] += (redshift_efficiency[i] - redshift_efficiency_errm[i])
ax2.fill_between(bins_middle, redshift_efficiency+redshift_efficiency_errp,redshift_efficiency-redshift_efficiency_errm, color='lightgray' )
ax2.errorbar(bins_middle, redshift_efficiency, yerr=[redshift_efficiency_errm,redshift_efficiency_errp], marker=None, fmt='.', color='k')
ax2.plot(bins_middle, redshift_efficiency, color='k', label='Redshift detection efficiency')
ax2.axhline(N_tot_Sw_comb/N_tot_Sw, color='r', ls='--', lw=1.2, label='Average detected fraction : %.2lf'%(N_tot_Sw_comb/N_tot_Sw))
ax2.legend(loc='best', numpoints=1)
ax2.set_ylim(-0.1, 1.5)
plt.setp(ax.get_xticklabels(),visible=False)
fig.subplots_adjust(hspace=0,wspace=0)
return
ax.hist(data, bins=bins, **kwargs)
else:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(data, bins=bins, **kwargs)
return
T_min = 2.05 # secondes
P23_min = 0.07 # ph/cm2/s
N_bin_min = 1 # Nb of bins with flx >= 50% of pflx -> more robust than T90>2s because of uncertainties on T90 measurement (see Stern+01)
verbose = 1
#################### Stern #######################
filename_S = 'catalogs/BATSE_cat/Stern_cat.txt'
name_S = pf.read_column(filename_S, 0, dtype=str, splitter='\t')
T90_S = pf.read_column(filename_S, 7, splitter='\t')
N_bin_S = pf.read_column(filename_S, 8, splitter='\t')
peak_flux_1024_S = pf.read_column(filename_S, 3, splitter='\t')
peak_flux_1024_mask_S = np.isfinite(peak_flux_1024_S)
final_peak_flux_1024_S = peak_flux_1024_S[peak_flux_1024_mask_S]
final_long_peak_flux_1024_S = peak_flux_1024_S[N_bin_S > N_bin_min]
#final_long_peak_flux_1024_S2 = peak_flux_1024_S[T90_S >= T_min]
#print 'max pflx Stern :', max(final_long_peak_flux_1024_S)
#print 'high pflx Stern :', final_long_peak_flux_1024_S[final_long_peak_flux_1024_S>30.]
if verbose >= 1 :
print( '----- Stern catalog -----')
print( 'Number of GRBs before N_bin cut : %d'%len(final_peak_flux_1024_S))
print( 'Number of GRBs after N_bin cut : %d'%len(final_long_peak_flux_1024_S))
print( '-------------------------')
print( '\n')
