def update_idis_tabs(wdir, tabs, tar):
load_config('%s/input.py' % wdir)
istep = core.get_istep()
data = load('%s/data/predictions-%d-sim.dat' % (wdir, istep))
blist = []
blist.append('thy')
blist.append('shift')
blist.append('residuals')
blist.append('prediction')
blist.append('N')
blist.append('Shift')
blist.append('W2')
blist.append('alpha')
blist.append('residuals-rep')
blist.append('r-residuals')
for _ in data['reactions']:
for idx in data['reactions'][_]:
print('update %s %d%s...' % (_, idx, tar))
tab = data['reactions'][_][idx]
for k in blist:
try:
del tab[k]
except:
continue
tab['value'] = np.mean(tab['prediction-rep'], axis=0)
for i in range(len(tab['prediction-rep'])):
tab['value%s' % (i + 1)] = tab['prediction-rep'][i]
del tab['prediction-rep']
df = pd.DataFrame(tab)
df.to_excel('%s/sim/%s%s.xlsx' % (wdir, idx, tar), index=False)
def get_norm(wdir, kc):
istep = core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep, replicas[0]) #--set conf as specified in istep
tab = {}
for replica in replicas:
order = replica['order'][istep]
#for _ in order: print(_,istep)
#sys.exit()
params = replica['params'][istep]
for i in range(len(order)):
if order[i][0] == 2:
reaction = order[i][1]
idx = order[i][2]
if reaction not in tab: tab[reaction] = {}
if idx not in tab[reaction]: tab[reaction][idx] = []
tab[reaction][idx].append(params[i])
for reaction in tab:
for idx in tab[reaction]:
norm = tab[reaction][idx][:]
tab[reaction][idx] = {}
tab[reaction][idx]['mean'] = np.mean(norm)
tab[reaction][idx]['std'] = np.std(norm)
return tab
def line_figure(self, wdir, Q2, dpi):
## this block may contain something not useful
load_config('%s/input.py' % wdir)
istep = core.get_istep()
# jar = load('%s/data/jar-%d.dat' % (wdir, istep))
labels = load('%s/data/labels-%d.dat' % (wdir, istep))
self.cluster = labels['cluster']
self.cluster_average_chi2 = labels['cluster_average_chi2']
self.best_cluster = np.argmin(self.cluster_average_chi2)
nrows, ncols = 1, 1
fig = py.figure(figsize=(ncols * 5.0, nrows * 3.0))
ax = py.subplot(nrows, ncols, 1)
## polarized PDF
if Q2 == None: Q2 = conf['Q20']
if Q2 == conf['Q20']:
self.xf_data = load('%s/data/ppdf-%d.dat' % (wdir, istep))
else:
self.xf_data = load('%s/data/ppdf-%d-%f.dat' % (wdir, istep, Q2))
print '\nplotting polarized PDF line figure from %s at Q2 = %.2f' % (
wdir, Q2)
self.plot_lines(ax, 'g', 'r', all_cluster=2)
ax.set_ylim(-0.11, 0.3)
ax.set_yticks([-0.1, 0.0, 0.1, 0.2])
ax.set_yticklabels([r'$-0.1$', r'$0.0$', r'$0.1$', r'$0.2$'])
# ax.text(0.7, 0.8, r'\boldmath$x\Delta g$', color = 'k', transform = axs[3].transAxes, size = 28)
ax.title.set_text(
r'\boldmath$x\Delta g~\mathrm{at}~Q^2 = %.2f~\mathrm{GeV}^2$' % Q2)
legends = ax.legend(frameon=0, loc='best')
for line in legends.get_lines():
line.set_linewidth(1.0)
ax.semilogx()
ax.set_xlim(8e-3, 9e-1)
ax.set_xticks([1e-2, 1e-1])
ax.tick_params(axis='both',
which='both',
right=True,
top=True,
direction='in',
labelsize=20)
ax.set_xticklabels([r'', r''])
ax.axhline(0.0, color='k', linestyle='dashdot', linewidth=0.5)
ax.set_xticks([0.01, 0.1, 0.5, 0.8])
ax.set_xticklabels([r'$0.01$', r'$0.1$', r'$0.5$', r'$0.8$'])
# py.subplots_adjust(left = 0.12, bottom = 0.08, right = 0.99, top = 0.97, wspace = None, hspace = 0.2)
py.tight_layout()
if Q2 == conf['Q20']:
py.savefig('%s/gallery/ppdf-lines-pjet-%d.png' % (wdir, istep),
dpi=dpi)
else:
py.savefig('%s/gallery/ppdf-lines-pjet-%d-%f.png' %
(wdir, istep, Q2),
dpi=dpi)
def get_chi2(wdir, kc):
istep = core.get_istep()
#replicas=core.get_replicas(wdir)
#core.mod_conf(istep,replicas[0]) #--set conf as specified in istep
predictions = load('%s/data/predictions-%d.dat' % (wdir, istep))
data = predictions['reactions']
tab = {}
for reaction in data:
for idx in data[reaction]:
if reaction not in tab: tab[reaction] = {}
if idx not in tab[reaction]: tab[reaction][idx] = {}
value = data[reaction][idx]['value']
alpha = data[reaction][idx]['alpha']
thy = np.mean(data[reaction][idx]['prediction-rep'], axis=0)
col = data[reaction][idx]['col'][0]
res = (value - thy) / alpha
chi2 = np.sum(res**2)
npts = res.size
chi2_npts = chi2 / npts
tab[reaction][idx]['col'] = col
tab[reaction][idx]['chi2'] = chi2
tab[reaction][idx]['npts'] = npts
tab[reaction][idx]['chi2_npts'] = chi2_npts
return tab
def histogram_figure(self, wdir, Q2, dpi):
## plot histogram for parameters of all flavors
load_config('%s/input.py' % wdir)
istep = core.get_istep()
# jar = load('%s/data/jar-%d.dat' % (wdir, istep))
labels = load('%s/data/labels-%d.dat' % (wdir, istep))
self.cluster = labels['cluster']
self.best_cluster = np.argmin(labels['cluster_average_chi2'])
if Q2 == None: Q2 = conf['Q20']
if Q2 == conf['Q20']:
self.ppdf_parameter_data = load('%s/data/ppdf-parameters-%d.dat' % (wdir, istep))
else:
self.ppdf_parameter_data = load('%s/data/ppdf-parameters-%d-%f.dat' % (wdir, istep, Q2))
shapes = self.ppdf_parameter_data.keys()
flavors = self.ppdf_parameter_data[shapes[0]].keys()
for _ in sorted(self.ppdf_parameter_data[shapes[0]][flavors[0]]):
print '\nplotting PPDF parameter %s histograms from %s' % (_, wdir)
if len(flavors) == 8:
n_rows, n_columns = 4, 2
figure = py.figure(figsize = (n_columns * 5.0, n_rows * 3.0))
axs = [py.subplot(n_rows, n_columns, count + 1) for count in range(8)]
sys.exit('please make a subplot configuration for your flavors')
elif len(flavors) == 7:
n_rows, n_columns = 4, 2
figure = py.figure(figsize = (n_columns * 5.0, n_rows * 3.0))
axs = [py.subplot(n_rows, n_columns, count + 1) for count in range(8) if count != 7]
else:
sys.exit('please make a subplot configuration for your flavors')
if sorted(flavors) == sorted(['g', 'up', 'ub', 'dp', 'db', 'sp', 'sb']):
self.ppdf_histogram(axs[0], 'up', _, r'\boldmath$u_+$')
self.ppdf_histogram(axs[1], 'ub', _, r'\boldmath$\overline{u}$')
self.ppdf_histogram(axs[2], 'dp', _, r'\boldmath$d_+$')
self.ppdf_histogram(axs[3], 'db', _, r'\boldmath$\overline{d}$')
self.ppdf_histogram(axs[4], 'sp', _, r'\boldmath$s_+$')
self.ppdf_histogram(axs[5], 'sb', _, r'\boldmath$\overline{s}$')
self.ppdf_histogram(axs[6], 'g', _, r'\boldmath$g$')
for ax in axs:
# ax.semilogx()
# ax.tick_params(axis = 'both', which = 'both', right = True, top = True, direction = 'in', labelsize = 20)
# ax.set_xticklabels([r'', r''])
ax.legend(frameon = 0, loc = 'best', fontsize = 17)
axs[0].title.set_text(r'$\mathrm{parameter}~%s~\mathrm{at}~Q^2 = %.2f~\mathrm{GeV^2}$' % (_, Q2))
axs[1].title.set_text(r'$\mathrm{parameter}~%s~\mathrm{at}~Q^2 = %.2f~\mathrm{GeV^2}$' % (_, Q2))
py.tight_layout()
if Q2 == conf['Q20']:
py.savefig('%s/gallery/ppdf-histogram-pjet-%s-%d.png' % (wdir, _, istep), dpi = dpi)
else:
py.savefig('%s/gallery/ppdf-histogram-pjet-%s-%d-%f.png' % (wdir, _, istep, Q2), dpi = dpi)
def make_figure(wdir,
task,
plot_with_factor=True,
only_best_cluster=True,
dpi=200):
## attribute 'plot_with_factor' is inherited from jet and not yet used
## it is kept there because someday it might be useful
if task == 1:
print('\nplotting PJET data from %s' % (wdir))
elif task == 2:
print('\nplotting PJET data over theory from %s' % (wdir))
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep, replicas[0]) #--set conf as specified in istep
predictions = load('%s/data/predictions-%d.dat' % (wdir, istep))
if 'pjet' not in predictions['reactions']:
print('PJET is not in data file')
return
labels = load('%s/data/labels-%d.dat' % (wdir, istep))
cluster = labels['cluster']
cluster_average_chi2 = labels['cluster_average_chi2']
best_cluster = np.argmin(cluster_average_chi2)
data = predictions['reactions']['pjet']
for idx in data:
predictions = copy.copy(data[idx]['prediction-rep'])
del data[idx]['prediction-rep']
del data[idx]['residuals-rep']
if only_best_cluster:
best_predictions = [
predictions[i] for i in range(len(predictions))
if cluster[i] == best_cluster
]
data[idx]['thy'] = np.mean(best_predictions, axis=0)
data[idx]['dthy'] = np.std(best_predictions, axis=0)**0.5
else:
all_predictions = [predictions[i] for i in range(len(predictions))]
data[idx]['thy'] = np.mean(all_predictions, axis=0)
data[idx]['dthy'] = np.std(all_predictions, axis=0)**0.5
if task == 1:
plot_data(wdir, data, istep, dpi, plot_with_factor)
# for idx in data:
# plot_data_separate(wdir, data[idx], istep, idx, dpi, plot_with_factor)
elif task == 2:
## this is copied from jet plot and not yet ready
plot_data_on_theory(wdir, data, istep, dpi)
return
def plot_obs(wdir, kc):
print('\nplotting ln data from %s' % (wdir))
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep, replicas[0]) #--set conf as specified in istep
predictions = load('%s/data/predictions-%d.dat' % (wdir, istep))
data = predictions['reactions']['ln']
plot_H1(wdir, istep, data[1000])
plot_ZEUS(wdir, istep, data[2000])
def plot_obs(wdir, only_best_cluster=True, dpi=200):
print('\nplotting dy data from %s' % (wdir))
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep, replicas[0]) #--set conf as specified in istep
predictions = load('%s/data/predictions-%d.dat' % (wdir, istep))
if 'dy' not in predictions['reactions']:
print('DY is not in data file')
return
labels = load('%s/data/labels-%d.dat' % (wdir, istep))
cluster = labels['cluster']
cluster_average_chi2 = labels['cluster_average_chi2']
best_cluster = np.argmin(cluster_average_chi2)
data = predictions['reactions']['dy']
for idx in data:
predictions = copy.copy(data[idx]['prediction-rep'])
del data[idx]['prediction-rep']
del data[idx]['residuals-rep']
if only_best_cluster:
best_predictions = [
predictions[i] for i in range(len(predictions))
if cluster[i] == best_cluster
]
data[idx]['thy'] = np.mean(best_predictions, axis=0)
data[idx]['dthy'] = np.std(best_predictions, axis=0)**0.5
else:
all_predictions = [predictions[i] for i in range(len(predictions))]
data[idx]['thy'] = np.mean(all_predictions, axis=0)
data[idx]['dthy'] = np.std(all_predictions, axis=0)**0.5
Q2_bins = []
# Q2_bins.append([30, 40])
Q2_bins.append([35, 45]) ## label pp: 37 < Q2 < 42 pd: idem
Q2_bins.append([45, 52]) ## label pp: 47 < Q2 < 49 pd: idem
Q2_bins.append([52, 60]) ## label pp: 54 < Q2 < 58 pd: 55 < Q2 < 57
Q2_bins.append([60, 68]) ## label pp: 63 < Q2 < 66 pd: 62 < Q2 < 65
Q2_bins.append([68, 75]) ## label pp: 70 < Q2 < 73 pd: 70 < Q2 < 72
Q2_bins.append([100, 140]) ## label pp: 118 < Q2 < 131 pd: 124 < Q2 < 129
Q2_bins.append([140, 160]) ## label pp: 148 < Q2 < 156 pd: 145 < Q2 < 154
Q2_bins.append([160, 280]) ## label pp: 173 < Q2 < 222 pd: 73 < Q2 < 280
plot_ratio(wdir, data, istep, Q2_bins, dpi)
return
def gen_conf_idis(wdir, idxs, tar, option=1, fn=None):
load_config('%s/input.py' % wdir)
istep = core.get_istep()
conf['steps'][istep]['datasets']['idis'] = []
conf['datasets']['idis']['filters'] = []
for idx in idxs:
conf['datasets']['idis']['xlsx'][idx] = './%s/sim/%d%s.xlsx' % (
wdir, idx, tar)
conf['steps'][istep]['datasets']['idis'].append(idx)
if option == 1: conf['idis grid'] = 'prediction'
elif option == 2: conf['idis grid'] = fn
return conf
def plot_obs(wdir, kc):
print('\nplotting dy-pion data from %s' % (wdir))
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep, replicas[0]) #--set conf as specified in istep
predictions = load('%s/data/predictions-%d.dat' % (wdir, istep))
if 'dy-pion' not in predictions['reactions']: return
data = predictions['reactions']['dy-pion']
plot_E615(wdir, istep, data[10001])
plot_NA10(wdir, istep, data[10002], data[10003])
return
def plot_obs(wdir, kc):
print('\nplotting DY-pion (qT) from %s' % (wdir))
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep, replicas[0]) #--set conf as specified in istep
predictions = load('%s/data/predictions-%d.dat' % (wdir, istep))
#print(predictions['reactions'].keys())
if 'pion_qT' not in predictions['reactions']: return
data = predictions['reactions']['pion_qT']
plot_E615_Q(wdir, istep, data[1001])
plot_E615_xF(wdir, istep, data[1002])
return
def gen_dist_from_fitpack(wdir,dist):
print('\ngenerating %s tables for benchmark using %s'%(dist,wdir))
load_config('%s/input.py'%wdir)
istep=core.get_istep()
core.mod_conf(istep) #--set conf as specified in istep
resman=RESMAN(nworkers=1,parallel=False,datasets=False)
parman=resman.parman
jar=load('%s/data/jar-%d.dat'%(wdir,istep))
replicas=jar['replicas']
X,Q2=gen_grid(dist)
qpd=conf[dist]
nx=len(X)
nQ2=len(Q2)
flavs=[-5,-4,-3,-2,-1,1,2,3,4,5,21]
fmap={-5:'bb',-4:'cb',-3:'sb',-2:'ub',-1:'db'}
fmap.update({5:'b',4:'c',3:'s',2:'u',1:'d'})
fmap.update({21:'g'})
#--gen qpd data per replica
checkdir('%s/benchmark'%wdir)
cnt=0
for par in replicas:
lprint('progress: %d/%d'%(cnt+1,len(replicas)))
parman.set_new_params(par)
data={}
for _ in Q2:
data[_]={}
for flav in flavs:
data[_][flav]=np.array([qpd.get_xF(x,_,fmap[flav]) for x in X])
save(data,'%s/benchmark/%s-%d.dat'%(wdir,dist,cnt))
cnt+=1
print
def plot_params(wdir,dist,kc):
load_config('%s/input.py'%wdir)
istep=core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep,replicas[0])
clusters,colors,nc,cluster_order = classifier.get_clusters(wdir,istep,kc)
_order = replicas[0]['order'][istep]
#--get correct order from dist
order = []
idx = []
for i in range(len(_order)):
if _order[i][1] != dist: continue
order.append(_order[i][2])
idx.append(i)
#--get correct params from dist
params = np.zeros((len(order),len(replicas)))
for i in range(len(order)):
for j in range(len(replicas)):
params[i][j] = replicas[j]['params'][istep][idx[i]]
#--create plot with enough space for # of parameters
nrows, ncols = np.ceil(len(order)/5.0), 5
fig = py.figure(figsize=(ncols*7,nrows*4))
X = np.linspace(1,len(replicas),len(replicas))
#--create plot
for i in range(len(order)):
ax = py.subplot(nrows,ncols, i+1)
ax.set_title('%s'%(order[i]), size=20)
#params = [replicas[j]['params'][istep][i] for j in range(len(replicas))]
color = [colors[clusters[j]] for j in range(len(replicas))]
ax.scatter(X,params[i],color=color)
ax.plot(X,np.ones(len(X))*np.average(params[i]),'k--',alpha=0.5)
filename='%s/gallery/%s-params.png'%(wdir,dist)
checkdir('%s/gallery'%wdir)
py.savefig(filename)
print 'Saving figure to %s'%filename
def print_individual_parameters(working_directory,
distribution,
norm,
index=0):
load_config('%s/input.py' % working_directory)
istep = core.get_istep()
jar = load('%s/data/jar-%d.dat' % (working_directory, istep))
if norm:
for i in range(len(jar['order'])):
if jar['order'][i][0] == 2:
print jar['order'][i][1].ljust(8), '%s' % str(
jar['order'][i][2]).ljust(
10), ':', jar['replicas'][index][i]
else:
for i in range(len(jar['order'])):
if (jar['order'][i][0] == 1) and (jar['order'][i][1]
== distribution):
print jar['order'][i][2].ljust(
13), ':', jar['replicas'][index][i]
def gen_tables(wdir, dist, file_name, info, info_only=False):
print('\ngenerating LHAPDF tables for %s using %s' % (dist, wdir))
load_config('%s/input.py' % wdir)
istep = core.get_istep()
core.mod_conf(istep) #--set conf as specified in istep
resman = RESMAN(nworkers=1, parallel=False, datasets=False)
parman = resman.parman
jar = load('%s/data/jar-%d.dat' % (wdir, istep))
replicas = jar['replicas']
#--check order consistency
order = jar['order']
parman.order = order
#--create output dir
checkdir(wdir + '/data/')
checkdir(wdir + '/data/%s/' % file_name)
#--gen lhapdf_data_files
if info_only == False:
cnt = 0
for par in replicas:
lprint('progress: %d/%d' % (cnt + 1, len(replicas)))
parman.set_new_params(par)
X, Q2, table = _gen_table(dist)
gen_lhapdf_dat_file(X, Q2, table, wdir, file_name, cnt)
cnt += 1
print
#--gen_lhapdf_info_file
X, Q2 = gen_grid(dist)
nrep = len(replicas)
gen_lhapdf_info_file(X, Q2, nrep, wdir, file_name, info)
def steps_comparison_figure(self, wdirs, Q2, dpi):
step_keys = sorted(wdirs.keys())
load_config('%s/input.py' % wdirs[step_keys[-1]])
istep = core.get_istep()
nrows, ncols = 1, 1
fig = py.figure(figsize=(ncols * 5.0, nrows * 3.0))
ax = py.subplot(nrows, ncols, 1)
colors = ['y', 'r', 'b', 'g', 'm']
## PPDF
self.xf_data = {}
self.cluster = {}
self.best_cluster = {}
labels = {}
if Q2 == None: Q2 = conf['Q20']
if Q2 == conf['Q20']:
for step_key in step_keys:
self.xf_data[step_key] = load('%s/data/ppdf-%d.dat' %
(wdirs[step_key], step_key))
labels[step_key] = load('%s/data/labels-%d.dat' %
(wdirs[step_key], step_key))
self.cluster[step_key] = labels[step_key]['cluster']
self.best_cluster[step_key] = np.argmin(
labels[step_key]['cluster_average_chi2'])
else:
for step_key in step_keys:
self.xf_data[step_key] = load('%s/data/ppdf-%d-%f.dat' %
(wdirs[step_key], step_key, Q2))
labels[step_key] = load('%s/data/labels-%d.dat' %
(wdirs[step_key], step_key))
self.cluster[step_key] = labels[step_key]['cluster']
self.best_cluster[step_key] = np.argmin(
labels[step_key]['cluster_average_chi2'])
print '\nplotting PPDF band figure with following steps at Q2 = %.2f' % Q2
print[wdirs[_] for _ in wdirs]
for i in range(len(step_keys)):
step = step_keys[i]
# alpha = (1.0 / len(step_keys)) * (len(step_keys) - i)
alpha = 0.5
color = colors[i]
label = r'$\mathrm{step~%02d}$' % step
self.plot_band_steps(ax, step, 'g', color, alpha, label)
ax.set_ylim(-0.11, 0.3)
ax.set_yticks([-0.1, 0.0, 0.1, 0.2])
ax.set_yticklabels([r'$-0.1$', r'$0.0$', r'$0.1$', r'$0.2$'])
# ax.text(0.1, 0.1, r'\boldmath$x\Delta g$', color = 'k', transform = ax.transAxes, size = 28)
ax.legend(frameon=0, loc='lower left', fontsize=7)
ax.semilogx()
ax.set_xlim(8e-3, 9e-1)
ax.set_xticks([1e-2, 1e-1])
ax.tick_params(axis='both',
which='both',
right=True,
top=True,
direction='in',
labelsize=20)
ax.set_xticklabels([r'', r''])
ax.axhline(0.0, color='k', linestyle='dashdot', linewidth=0.5)
ax.set_xticks([0.01, 0.1, 0.5])
ax.set_xticklabels([r'$0.01$', r'$0.1$', r'$0.5$'])
ax.set_ylabel(r'$x \Delta g$', size=15)
ax.set_xlabel(r'\boldmath$x$', size=15)
ax.xaxis.set_label_coords(1.05, 0.0)
py.tight_layout()
# py.subplots_adjust(left=0.05, bottom=0.04, right=0.99, top=0.99, wspace=0.17, hspace=0.04)
if Q2 == conf['Q20']:
py.savefig('%s/gallery/ppdf-steps-pjet-%d.png' %
(wdirs[step_keys[-1]], istep),
dpi=dpi)
else:
py.savefig('%s/gallery/ppdf-steps-pjet-%d-%f.png' %
(wdirs[step_keys[-1]], istep, Q2),
dpi=dpi)
def print_grouped_parameters(working_directory,
distribution_name,
i_replica=1):
## print parameters from replicas and PDF class to compare
load_config('%s/input.py' % working_directory)
istep = core.get_istep()
replicas = core.get_replicas(working_directory)
core.mod_conf(istep, replicas[0]) ## set conf as specified in istep
if distribution_name not in conf['steps'][istep]['active distributions']:
print('%s-proton is not an active distribution' % distribution_name)
return
resman = RESMAN(nworkers=1, parallel=False, datasets=False)
parman = resman.parman
parman.order = replicas[0]['order'][
istep] ## make sure 'parman' uses the same order as all the replicas do
# print parman.order
distribution = conf[distribution_name]
print('%s parameters in class' % distribution_name)
core.mod_conf(istep, replicas[i_replica - 1])
parman.set_new_params(replicas[i_replica - 1]['params'][istep],
initial=True)
for name, value in distribution.params.iteritems():
if value[0] != 0.0:
print '%7s: %.5e, %.5e, %.5e, %.5e, %.5e' % (
name, value[0], value[1], value[2], value[3], value[4])
print('%s parameters in replicas' % distribution_name)
orders = []
unique_orders = []
values = []
for i in range(len(replicas[i_replica - 1]['order'][istep])):
order = replicas[i_replica - 1]['order'][istep][i]
value = replicas[i_replica - 1]['params'][istep][i]
if (order[0] == 1) and (order[1] == distribution_name):
orders.append(order[2])
unique_orders.append(order[2].split(' ')[0])
values.append(value)
unique_orders = list(set(unique_orders))
for unique_order in unique_orders:
parameters = []
all_parameters = {'N': None, 'a': 0.0, 'b': 0.0, 'c': 0.0, 'd': 0.0}
for i in range(len(orders)):
if orders[i].split(' ')[0] == unique_order:
all_parameters[orders[i].split(' ')[1]] = values[i]
if all_parameters == {
'N': None,
'a': 0.0,
'b': 0.0,
'c': 0.0,
'd': 0.0
}:
continue
if all_parameters['N'] == None:
print '%7s: None, %.5e, %.5e, %.5e, %.5e' % (
unique_order, all_parameters['a'], all_parameters['b'],
all_parameters['c'], all_parameters['d'])
else:
print '%7s: %.5e, %.5e, %.5e, %.5e, %.5e' % (
unique_order, all_parameters['N'], all_parameters['a'],
all_parameters['b'], all_parameters['c'], all_parameters['d'])
def steps_comparison_figure(self, wdirs, Q2, dpi):
step_keys = sorted(wdirs.keys())
load_config('%s/input.py' % wdirs[step_keys[-1]])
istep = core.get_istep()
nrows, ncols = 2, 2
fig = py.figure(figsize=(ncols * 5.0, nrows * 3.0))
axs = [py.subplot(nrows, ncols, cnt + 1) for cnt in range(4)]
colors = ['k', 'r', 'g', 'Yellow', 'b']
## PPDF
self.xf_data = {}
self.cluster = {}
self.best_cluster = {}
labels = {}
if Q2 == None: Q2 = conf['Q20']
if Q2 == conf['Q20']:
for step_key in step_keys:
self.xf_data[step_key] = load('%s/data/ppdf-%d.dat' %
(wdirs[step_key], step_key))
labels[step_key] = load('%s/data/labels-%d.dat' %
(wdirs[step_key], step_key))
self.cluster[step_key] = labels[step_key]['cluster']
self.best_cluster[step_key] = np.argmin(
labels[step_key]['cluster_average_chi2'])
else:
for step_key in step_keys:
self.xf_data[step_key] = load('%s/data/ppdf-%d-%f.dat' %
(wdirs[step_key], step_key, Q2))
labels[step_key] = load('%s/data/labels-%d.dat' %
(wdirs[step_key], step_key))
self.cluster[step_key] = labels[step_key]['cluster']
self.best_cluster[step_key] = np.argmin(
labels[step_key]['cluster_average_chi2'])
print '\nplotting PPDF band figure with following steps at Q2 = %.2f' % Q2
print[wdirs[_] for _ in wdirs]
ax = axs[0]
for i in range(len(step_keys)):
step = step_keys[i]
# alpha = (1.0 / len(step_keys)) * (len(step_keys) - i)
alpha = 0.5
color = colors[i]
self.plot_band_steps(ax, step, 'uv', color, alpha)
self.plot_band_steps(ax, step, 'dv', color, alpha)
ax.set_ylim(0.0, 0.5)
ax.set_yticks([0.0, 0.1, 0.2, 0.3, 0.4, 0.5])
ax.set_yticklabels([r'$0.1$', r'$0.2$', r'$0.3$', r'$0.4$', r'$0.5$'])
ax.text(0.6,
0.3,
r'\boldmath$x\Delta u^+$',
color='k',
transform=axs[0].transAxes,
size=28)
ax = axs[1]
for i in range(len(step_keys)):
step = step_keys[i]
# alpha = (1.0 / len(step_keys)) * (len(step_keys) - i)
alpha = 0.5
color = colors[i]
self.plot_band_steps(ax, step, 'd/u', color, alpha)
ax.set_ylim(-0.2, 0.0)
ax.set_yticks([-0.05, -0.1, -0.15])
ax.set_yticklabels([r'$-0.05$', r'$-0.10$', r'$-0.15$'])
ax.text(0.05,
0.15,
r'\boldmath$x\Delta d^+$',
color='k',
transform=axs[1].transAxes,
size=28)
ax = axs[2]
for i in range(len(step_keys)):
step = step_keys[i]
# alpha = (1.0 / len(step_keys)) * (len(step_keys) - i)
alpha = 0.5
color = colors[i]
self.plot_band_steps(ax, step, 'db+ub', color, alpha)
ax.set_ylim(-0.1, 0.05)
ax.set_yticks([-0.08, -0.04, 0.0, 0.04])
ax.set_yticklabels([r'$-0.08$', r'$-0.04$', r'$0.00$', r'$0.04$'])
ax.text(0.1,
0.7,
r'\boldmath$x\Delta s^+$',
color='k',
transform=axs[2].transAxes,
size=28)
ax = axs[3]
for i in range(len(step_keys)):
step = step_keys[i]
# alpha = (1.0 / len(step_keys)) * (len(step_keys) - i)
alpha = 0.5
color = colors[i]
self.plot_band_steps(ax, step, 'db-ub', color, alpha)
ax.set_ylim(-0.11, 0.3)
ax.set_yticks([-0.1, 0.0, 0.1, 0.2])
ax.set_yticklabels([r'$-0.1$', r'$0.0$', r'$0.1$', r'$0.2$'])
ax.text(0.7,
0.8,
r'\boldmath$x\Delta g$',
color='k',
transform=axs[3].transAxes,
size=28)
ax = axs[4]
for i in range(len(step_keys)):
step = step_keys[i]
# alpha = (1.0 / len(step_keys)) * (len(step_keys) - i)
alpha = 0.5
color = colors[i]
self.plot_band_steps(ax, step, 's+sb', color, alpha)
ax.text(0.6,
0.8,
r'\boldmath$x(s\!+\!\overline{s})$',
color='k',
transform=ax.transAxes,
size=28)
ax.set_ylim(0.0, 0.48)
ax.set_yticks([0.0, 0.1, 0.2, 0.3, 0.4])
ax.set_yticklabels([r'$0$', r'', r'$0.2$', r'', r'$0.4$'])
ax = axs[5]
for i in range(len(step_keys)):
step = step_keys[i]
# alpha = (1.0 / len(step_keys)) * (len(step_keys) - i)
alpha = 0.5
color = colors[i]
self.plot_band_steps(ax, step, 'rs', color, alpha)
ax.text(0.05,
0.78,
r'\boldmath$R_s$',
color='k',
transform=ax.transAxes,
size=30)
ax.set_ylim(0.0, 1.6)
ax.set_yticks([0.0, 0.5, 1.0, 1.5])
ax.set_yticklabels([r'$0$', r'$0.5$', r'$1$', r'$1.5$'])
ax = axs[6]
for i in range(len(step_keys)):
step = step_keys[i]
# alpha = (1.0 / len(step_keys)) * (len(step_keys) - i)
alpha = 0.5
color = colors[i]
label = r'$\mathrm{step~%02d}$' % step
self.plot_band_steps(ax, step, 'g', color, alpha, label)
ax.text(0.8,
0.8,
r'\boldmath$xg$',
color='k',
transform=ax.transAxes,
size=31)
ax.set_ylim(0.0, 2.5)
ax.set_yticks([0.0, 0.5, 1.0, 1.5, 2.0])
ax.legend(frameon=0,
loc='best',
bbox_to_anchor=[1.87, 0.9],
fontsize=20)
for ax in axs:
ax.semilogx()
ax.set_xlim(8e-3, 9e-1)
ax.set_xticks([1e-2, 1e-1])
# ax.xaxis.set_label_coords(0.95, -0.05)
ax.tick_params(axis='both',
which='both',
right=True,
top=True,
direction='in',
labelsize=20)
ax.set_xticklabels([r'', r''])
ax.xaxis.set_label_coords(0.7, -0.05)
ax.legend(frameon=0, loc='best')
axs[2].axhline(0.0, color='k', linestyle='dashdot', linewidth=0.5)
axs[3].axhline(0.0, color='k', linestyle='dashdot', linewidth=0.5)
for i in range(len(axs) - 1, len(axs) - 1 - ncols, -1):
axs[i].set_xlabel(r'\boldmath$x$', size=30)
# axs[i].text(0.84, -0.095, r'$0.5$', color = 'k', transform = ax.transAxes, size = 20)
axs[i].set_xticks([0.01, 0.1, 0.5, 0.8])
axs[i].set_xticklabels([r'$0.01$', r'$0.1$', r'$0.5$', r'$0.8$'])
py.tight_layout()
py.subplots_adjust(left=0.05,
bottom=0.04,
right=0.99,
top=0.99,
wspace=0.17,
hspace=0.04)
if Q2 == conf['Q20']:
py.savefig('%s/gallery/ppdf-steps-%d.png' %
(wdirs[step_keys[-1]], istep),
dpi=dpi)
else:
py.savefig('%s/gallery/ppdf-steps-%d-%f.png' %
(wdirs[step_keys[-1]], istep, Q2),
dpi=dpi)
def line_figure(self, wdir, Q2, dpi):
## this block may contain something not useful
load_config('%s/input.py' % wdir)
istep = core.get_istep()
# jar = load('%s/data/jar-%d.dat' % (wdir, istep))
labels = load('%s/data/labels-%d.dat' % (wdir, istep))
self.cluster = labels['cluster']
self.cluster_average_chi2 = labels['cluster_average_chi2']
self.best_cluster = np.argmin(self.cluster_average_chi2)
nrows, ncols = 2, 2
fig = py.figure(figsize=(ncols * 5.0, nrows * 3.0))
axs = [py.subplot(nrows, ncols, cnt + 1) for cnt in range(4)]
## polarized PDF
if Q2 == None: Q2 = conf['Q20']
if Q2 == conf['Q20']:
self.xf_data = load('%s/data/ppdf-%d.dat' % (wdir, istep))
else:
self.xf_data = load('%s/data/ppdf-%d-%f.dat' % (wdir, istep, Q2))
print '\nplotting polarized PDF line figure from %s at Q2 = %.2f' % (
wdir, Q2)
self.plot_lines(axs[0], 'up', 'r', all_cluster=2)
self.plot_lines(axs[1], 'dp', 'r', all_cluster=2)
self.plot_lines(axs[2], 'sp', 'r', all_cluster=2)
self.plot_lines(axs[3], 'g', 'r', all_cluster=2)
axs[0].set_ylim(0.0, 0.5)
axs[0].set_yticks([0.0, 0.1, 0.2, 0.3, 0.4, 0.5])
axs[0].set_yticklabels(
[r'$0.1$', r'$0.2$', r'$0.3$', r'$0.4$', r'$0.5$'])
# axs[0].text(0.6, 0.3, r'\boldmath$x\Delta u^+$', color = 'k', transform = axs[0].transAxes, size = 28)
axs[0].title.set_text(
r'\boldmath$x\Delta u^+~\mathrm{at}~Q^2 = %.2f~\mathrm{GeV}^2$' %
Q2)
axs[1].set_ylim(-0.2, 0.0)
axs[1].set_yticks([-0.05, -0.1, -0.15])
axs[1].set_yticklabels([r'$-0.05$', r'$-0.10$', r'$-0.15$'])
# axs[1].text(0.05, 0.15, r'\boldmath$x\Delta d^+$', color = 'k', transform = axs[1].transAxes, size = 28)
axs[1].title.set_text(
r'\boldmath$x\Delta d^+~\mathrm{at}~Q^2 = %.2f~\mathrm{GeV}^2$' %
Q2)
axs[2].set_ylim(-0.1, 0.05)
axs[2].set_yticks([-0.08, -0.04, 0.0, 0.04])
axs[2].set_yticklabels([r'$-0.08$', r'$-0.04$', r'$0.00$', r'$0.04$'])
# axs[2].text(0.1, 0.7, r'\boldmath$x\Delta s^+$', color = 'k', transform = axs[2].transAxes, size = 28)
axs[2].title.set_text(r'\boldmath$x\Delta s^+$')
axs[3].set_ylim(-0.11, 0.3)
axs[3].set_yticks([-0.1, 0.0, 0.1, 0.2])
axs[3].set_yticklabels([r'$-0.1$', r'$0.0$', r'$0.1$', r'$0.2$'])
# axs[3].text(0.7, 0.8, r'\boldmath$x\Delta g$', color = 'k', transform = axs[3].transAxes, size = 28)
axs[3].title.set_text(r'\boldmath$x\Delta g$')
for ax in axs:
ax.semilogx()
ax.set_xlim(8e-3, 9e-1)
ax.set_xticks([1e-2, 1e-1])
# ax.xaxis.set_label_coords(0.95, -0.05)
ax.tick_params(axis='both',
which='both',
right=True,
top=True,
direction='in',
labelsize=20)
ax.set_xticklabels([r'', r''])
axs[2].axhline(0.0, color='k', linestyle='dashdot', linewidth=0.5)
axs[3].axhline(0.0, color='k', linestyle='dashdot', linewidth=0.5)
# for i in range(len(axs)):
# if (i % ncols) == 0: axs[i].set_ylabel(r'$xf(x)$', size = 20)
for i in range(len(axs) - 1, len(axs) - 1 - ncols, -1):
axs[i].set_xlabel(r'\boldmath$x$', size=30)
# axs[i].text(0.84, -0.095, r'$0.5$', color = 'k', transform = ax.transAxes, size = 20)
axs[i].set_xticks([0.01, 0.1, 0.5, 0.8])
axs[i].set_xticklabels([r'$0.01$', r'$0.1$', r'$0.5$', r'$0.8$'])
legends = axs[0].legend(frameon=0, loc='best')
for line in legends.get_lines():
line.set_linewidth(1.0)
py.subplots_adjust(left=0.12,
bottom=0.08,
right=0.99,
top=0.97,
wspace=None,
hspace=0.2)
py.tight_layout()
if Q2 == conf['Q20']:
py.savefig('%s/gallery/ppdf-lines-%d.png' % (wdir, istep), dpi=dpi)
else:
py.savefig('%s/gallery/ppdf-lines-%d-%f.png' % (wdir, istep, Q2),
dpi=dpi)
def line_figure1(self, wdir, had):
# self.cluster, colors, nc, order = self.get_clusters(wdir, istep)
print 'Generating ff plot'
load_config('%s/input.py' % wdir)
istep = core.get_istep()
jar = load('%s/data/jar-%d.dat' % (wdir, istep))
labels = load('%s/data/labels-%d.dat' % (wdir, istep))
self.cluster = labels['cluster']
n_replicas = len(self.cluster)
self.best_cluster = 0
nrows, ncols = 2, 3
fig = py.figure(figsize=(ncols * 5.0, nrows * 3.0))
# AX = [py.subplot(nrows, ncols, cnt) for cnt in range(1, 9)]
AX = [py.subplot(nrows, ncols, cnt + 1) for cnt in range(6)]
## FF
for i in had:
self.data = load('%s/data/ff%s-%d.dat' % (wdir, i, istep))
if i == 'pion':
c = 'r'
lab = r'$\pi$'
elif i == 'kaon':
c = 'b'
lab = r'$K$'
elif i == 'hadron':
c = 'k'
lab = r'$h$'
self.plot_lines(AX[0], 'u+ub', c, n_replicas, lab)
self.plot_lines(AX[1], 'd+db', c, n_replicas)
self.plot_lines(AX[2], 's+sb', c, n_replicas)
self.plot_lines(AX[3], 'c+cb', c, n_replicas)
self.plot_lines(AX[4], 'b+bb', c, n_replicas)
self.plot_lines(AX[5], 'g', c, n_replicas)
AX[0].text(0.9, 0.55, r'$u^+$', color='k', size=20)
AX[0].set_ylabel(r'$zD(z)$', size=20)
AX[0].legend(loc='upper center')
AX[1].text(0.9, 0.55, r'$d^+$', color='k', size=20)
AX[2].text(0.9, 0.55, r'$s^+$', color='k', size=20)
AX[3].text(0.9, 0.55, r'$c^+$', color='k', size=20)
AX[3].set_ylabel(r'$zD(z)$', size=20)
AX[3].set_xlabel(r'$z$', size=20, x=0.9, va='baseline')
AX[4].text(0.9, 0.55, r'$b^+$', color='k', size=20)
AX[4].set_xlabel(r'$z$', size=20, x=0.9, va='baseline')
AX[5].text(0.9, 0.55, r'$g$', color='k', size=20)
AX[5].set_xlabel(r'$z$', size=20, x=0.9, va='baseline')
for ax in AX:
ax.set_ylim(0.0, 0.6)
# ax.set_yticks([0.2,0.6,1.0,1.4])
ax.set_xlim(0.1, 1.0)
ax.set_xticks([0.2, 0.4, 0.6, 0.8])
py.subplots_adjust(left=0.12,
bottom=0.08,
right=0.99,
top=0.97,
wspace=None,
hspace=0.2)
py.tight_layout()
py.savefig('%s/gallery/ff-line-plots1-%d.png' % (wdir, istep),
dpi=1000)
def chi2_histogram(wdir, reaction, dataset, dpi):
conf['datasets'] = {}
if reaction.lower() == 'jet':
from obslib.jets.reader import READER
conf['datasets']['jet'] = {}
conf['datasets']['jet']['xlsx'] = {}
conf['datasets']['jet']['xlsx'][
dataset] = 'jets/expdata/%s.xlsx' % dataset
## please notice the inconsistence of names, 'jet' and 'jets'
## so please do not remove this part
elif reaction.lower() == 'pjet':
from obslib.pjets.reader import READER
conf['datasets']['pjet'] = {}
conf['datasets']['pjet']['xlsx'] = {}
conf['datasets']['pjet']['xlsx'][
dataset] = 'pjets/expdata/%s.xlsx' % dataset
## please notice the inconsistence of names, 'pjet' and 'pjets'
## so please do not remove this part
elif reaction.lower() == 'idis':
from obslib.idis.reader import READER
elif reaction.lower() == 'sidis':
from obslib.sidis.reader import READER
elif reaction.lower() == 'pidis':
from obslib.pidis.reader import READER
elif reaction.lower() == 'psidis':
from obslib.psidis.reader import READER
elif reaction.lower() == 'dy':
from obslib.dy.reader import READER
elif reaction.lower() == 'sia':
from obslib.sia.reader import READER
conf['aux'] = AUX()
if reaction not in conf['datasets']:
conf['datasets'][reaction] = {}
conf['datasets'][reaction]['xlsx'] = {}
conf['datasets'][reaction]['xlsx'][dataset] = '%s/expdata/%s.xlsx' % (
reaction, dataset)
data_table = READER().load_data_sets(reaction)
## plot histogram of relative 'chi2' for 'dataset' in 'reaction'
load_config('%s/input.py' % wdir)
istep = core.get_istep()
collaboration = data_table[dataset]['col'][0]
print('\nplotting relative chi2 histogram for %d in %s from %s' %
(dataset, reaction, wdir))
replicas = core.get_replicas(wdir)
relative_chi2 = []
for replica in replicas:
# print replica['chi2'][reaction][dataset]
relative_chi2.append(replica['chi2'][reaction][dataset]['chi2'] /
float(replica['chi2'][reaction][dataset]['npts']))
n_rows, n_columns = 1, 1
figure, ax = py.subplots(n_rows, n_columns)
ax.hist(relative_chi2,
len(relative_chi2),
histtype='bar',
color='b',
label=r'$\mathrm{%s,~%s}$' %
(reaction.upper(), collaboration.upper()))
ax.legend(fontsize=20, loc='upper right')
# ax.set_ylabel(r'\boldmath$\mathrm{n}$', size = 24)
# ax.yaxis.set_label_coords(-0.17, 2.0)
ax.set_xlabel(r'\boldmath$\chi^2/\mathrm{n}$', size=24)
# ax.xaxis.set_label_coords(0.90, -0.12)
py.tight_layout()
py.savefig('%s/gallery/chi2-histogram-%s-%s-%d.png' %
(wdir, reaction, collaboration, istep),
dpi=dpi)
def gen_xf(wdir, had, flavors=['g', 'u', 'ub', 'd', 'db', 's', 'sb'], Q2=None):
fflabel = 'ff%s' % had
print('\ngenerating ff-%s from %s' % (had, wdir))
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep, replicas[0]) ## set conf as specified in istep
if fflabel not in conf['steps'][istep]['active distributions']:
print('ff-%s not in active distribution' % had)
return
resman = RESMAN(nworkers=1, parallel=False, datasets=False)
parman = resman.parman
jar = load('%s/data/jar-%d.dat' % (wdir, istep))
## 'jar' contains parameters and their orders
replicas = jar['replicas']
## 'jar['replicas']' is a list, in which each element is a list of parameters obeying 'jar['order']'
ff = conf[fflabel]
## setup kinematics
X = np.linspace(0.01, 0.99, 100)
if Q2 == None: Q2 = conf['Q20']
## compute XF for all replicas
XF = {}
cnt = 0
for par in replicas:
cnt += 1
lprint('%d/%d' % (cnt, len(replicas)))
## filter
#flag=False
#params=replica['params'][istep]
#order=replica['order'][istep]
#for i in range(len(order)):
# if order[i][0]!=1:continue
# if order[i][1]!='pdf':continue
# #if order[i][2]=='s1 a':
# # if params[i]<-0.9: flag=True
#if flag: continue
parman.set_new_params(par, initial=True)
#print
#print conf['ffpion'].get_xF(0.5,10.0,'u')
#print conf['ffkaon'].get_xF(0.5,10.0,'u')
#print ff.get_xF(0.5,10.0,'u')
for flavor in flavors:
if flavor not in XF: XF[flavor] = []
if flavor == 'c' or flavor == 'cb' or flavor == 'c+cb':
_Q2 = conf['aux'].mc2 + 1
elif flavor == 'b' or flavor == 'bb' or flavor == 'b+bb':
_Q2 = conf['aux'].mb2 + 1
else:
_Q2 = Q2
if flavor == 'u+ub':
func = lambda x: ff.get_xF(x, _Q2, 'u') + ff.get_xF(
x, _Q2, 'ub')
elif flavor == 'd+db':
func = lambda x: ff.get_xF(x, _Q2, 'd') + ff.get_xF(
x, _Q2, 'db')
elif flavor == 's+sb':
func = lambda x: ff.get_xF(x, _Q2, 's') + ff.get_xF(
x, _Q2, 'cb')
elif flavor == 'c+cb':
func = lambda x: ff.get_xF(x, _Q2, 'c') + ff.get_xF(
x, _Q2, 'cb')
elif flavor == 'b+bb':
func = lambda x: ff.get_xF(x, _Q2, 'b') + ff.get_xF(
x, _Q2, 'bb')
else:
func = lambda x: ff.get_xF(x, _Q2, flavor)
XF[flavor].append([func(x) for x in X])
#print func(0.5)
print
checkdir('%s/data' % wdir)
if Q2 == conf['Q20']:
save({
'X': X,
'Q2': Q2,
'XF': XF
}, '%s/data/ff%s-%d.dat' % (wdir, had, istep))
else:
save({
'X': X,
'Q2': Q2,
'XF': XF
}, '%s/data/ff%s-%d-%d.dat' % (wdir, had, istep, int(Q2)))
def make_figure(wdir, task, only_best_cluster=True, dpi=200):
if task == 1:
print('\nplotting PIDIS data from %s' % (wdir))
elif task == 2:
print('\nplotting PIDIS data over theory from %s' % (wdir))
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
core.mod_conf(istep, replicas[0]) #--set conf as specified in istep
predictions = load('%s/data/predictions-%d.dat' % (wdir, istep))
if 'pidis' not in predictions['reactions']:
print('PIDIS is not in data file')
return
labels = load('%s/data/labels-%d.dat' % (wdir, istep))
cluster = labels['cluster']
cluster_average_chi2 = labels['cluster_average_chi2']
best_cluster = np.argmin(cluster_average_chi2)
data = predictions['reactions']['pidis']
for idx in data:
predictions = copy.copy(data[idx]['prediction-rep'])
del data[idx]['prediction-rep']
del data[idx]['residuals-rep']
if only_best_cluster:
best_predictions = [
predictions[i] for i in range(len(predictions))
if cluster[i] == best_cluster
]
data[idx]['thy'] = np.mean(best_predictions, axis=0)
data[idx]['dthy'] = np.std(best_predictions, axis=0)
else:
all_predictions = [predictions[i] for i in range(len(predictions))]
data[idx]['thy'] = np.mean(all_predictions, axis=0)
data[idx]['dthy'] = np.std(all_predictions, axis=0)
maps = generate_maps()
subset_bins = pick_subsets(data)
# log_list = []
if task == 1:
indices = {}
for idx in data:
observable = data[idx]['obs'][0]
target = data[idx]['target'][0]
collaboration = data[idx]['col'][0]
if (observable == 'A1') or (observable == 'Apa'):
if target == 'p':
if collaboration.startswith('JLab') != True:
if 'Apa_proton' not in indices:
indices['Apa_proton'] = []
indices['Apa_proton'].append(idx)
elif collaboration.startswith('JLabHB(EG1DVCS)') == True:
if 'Apa_proton_DVCS' not in indices:
indices['Apa_proton_DVCS'] = []
indices['Apa_proton_DVCS'].append(idx)
elif collaboration.startswith('JLabHB(EG1b)') == True:
if 'Apa_proton_EG1b' not in indices:
indices['Apa_proton_EG1b'] = []
indices['Apa_proton_EG1b'].append(idx)
elif target == 'd':
if collaboration.startswith('JLab') != True:
if 'Apa_deuteron' not in indices:
indices['Apa_deuteron'] = []
indices['Apa_deuteron'].append(idx)
elif collaboration.startswith('JLabHB(EG1DVCS)') == True:
if 'Apa_deuteron_DVCS' not in indices:
indices['Apa_deuteron_DVCS'] = []
indices['Apa_deuteron_DVCS'].append(idx)
elif collaboration.startswith('JLabHB(EG1b)') == True:
if 'Apa_deuteron_EG1b' not in indices:
indices['Apa_deuteron_EG1b'] = []
indices['Apa_deuteron_EG1b'].append(idx)
elif (observable == 'A2') or (observable == 'Ape') or (observable
== 'Atpe'):
if target == 'p':
if collaboration.startswith('JLab') != True:
if 'Ape_proton' not in indices:
indices['Ape_proton'] = []
indices['Ape_proton'].append(idx)
elif target == 'd':
if collaboration.startswith('JLab') != True:
if 'Ape_deuteron' not in indices:
indices['Ape_deuteron'] = []
indices['Ape_deuteron'].append(idx)
if target == 'h':
if 'helium' not in indices:
indices['helium'] = []
indices['helium'].append(idx)
for key in indices:
print(key)
if key == 'Apa_proton':
data_Apa_proton(wdir, data, indices[key], subset_bins, maps,
istep, dpi)
elif key == 'Apa_proton_DVCS':
data_Apa_proton_DVCS(wdir, data, indices[key], subset_bins,
maps, istep, dpi)
elif key == 'Apa_proton_EG1b':
data_Apa_proton_EG1b(wdir, data, indices[key], subset_bins,
maps, istep, dpi)
elif key == 'Apa_deuteron':
data_Apa_deuteron(wdir, data, indices[key], subset_bins, maps,
istep, dpi)
elif key == 'Apa_deuteron_DVCS':
data_Apa_deuteron_DVCS(wdir, data, indices[key], subset_bins,
maps, istep, dpi)
elif key == 'Apa_deuteron_EG1b':
data_Apa_deuteron_EG1b(wdir, data, indices[key], subset_bins,
maps, istep, dpi)
elif key == 'Ape_proton':
data_Ape_proton(wdir, data, indices[key], subset_bins, maps,
istep, dpi)
elif key == 'Ape_deuteron':
data_Ape_deuteron(wdir, data, indices[key], subset_bins, maps,
istep, dpi)
elif key == 'helium':
data_helium(wdir, data, indices[key], subset_bins, maps, istep,
dpi)
elif task == 2:
plot_data_on_theory(wdir, data, istep, dpi)
return
def get_parameters(wdir, Q2=None):
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
## 'conf' will be modified for each replica individually later in the loop over 'replicas'
## the reason for doing this is that 'fix parameters' has to be set correctly for each replica
if 'ppdf' not in conf['steps'][istep]['active distributions']:
print('ppdf-proton not in active distribution')
return
resman = RESMAN(nworkers=1, parallel=False, datasets=False)
parman = resman.parman
parman.order = replicas[0]['order'][
istep] ## make sure 'parman' uses the same order as all the replicas do
# print parman.order
ppdf = conf['ppdf']
## setup kinematics
if Q2 == None: Q2 = conf['Q20']
## get parameters for all flavors of PDF
print('\ngetting ppdf-parameters from %s at Q2 = %.2f' % (wdir, Q2))
## check if any of the shapes are fixed
shape_1 = []
shape_2 = []
shape_3 = []
for parameter in conf['params']['ppdf']:
if '1' in parameter:
shape_1.append(conf['params']['ppdf'][parameter]['fixed'])
elif '2' in parameter:
shape_2.append(conf['params']['ppdf'][parameter]['fixed'])
elif '3' in parameter:
shape_3.append(conf['params']['ppdf'][parameter]['fixed'])
else:
print('there seems to be more than three shapes')
print(parameter)
sys.exit('please update script %s' % __file__)
fixed_shape_1 = False
fixed_shape_2 = False
fixed_shape_3 = False
if (len(shape_1) != 0) and all([_ == True for _ in shape_1]):
fixed_shape_1 = True
elif len(shape_1) == 0:
fixed_shape_1 = True
if (len(shape_2) != 0) and all([_ == True for _ in shape_2]):
fixed_shape_2 = True
elif len(shape_2) == 0:
fixed_shape_2 = True
if (len(shape_3) != 0) and all([_ == True for _ in shape_3]):
fixed_shape_3 = True
elif len(shape_3) == 0:
fixed_shape_3 = True
parameters = {}
if not fixed_shape_1: parameters[1] = {}
if not fixed_shape_2: parameters[2] = {}
if not fixed_shape_3: parameters[3] = {}
n_replicas = len(replicas)
for i in range(n_replicas):
lprint('%d/%d' % (i + 1, n_replicas))
parman.order = copy.copy(replicas[i]['order'][istep])
core.mod_conf(istep, replicas[i])
parman.set_new_params(replicas[i]['params'][istep], initial=True)
for flavor, value in ppdf.params.iteritems():
for j in parameters:
if str(j) in flavor:
flavor_key = flavor.replace(str(j), '')
if flavor_key not in parameters[j]:
parameters[j][flavor_key] = {
'n': [],
'a': [],
'b': [],
'c': [],
'd': []
}
parameters[j][flavor_key]['n'].append(value[0])
parameters[j][flavor_key]['a'].append(value[1])
parameters[j][flavor_key]['b'].append(value[2])
parameters[j][flavor_key]['c'].append(value[3])
parameters[j][flavor_key]['d'].append(value[4])
else:
pass
## remove c or d parameters if fixed in all flavors and shapes
## this is to avoid producing empty figures
shapes_fixed_c = []
shapes_fixed_d = []
for shape in parameters:
flavors_fixed_c = []
flavors_fixed_d = []
for flavor in parameters[shape]:
cs = parameters[shape][flavor]['c']
ds = parameters[shape][flavor]['d']
if all([_ == cs[0] for _ in cs]):
flavors_fixed_c.append(True)
else:
flavors_fixed_c.append(False)
if all([_ == ds[0] for _ in ds]):
flavors_fixed_d.append(True)
else:
flavors_fixed_d.append(False)
if all(flavors_fixed_c):
shapes_fixed_c.append(True)
else:
shapes_fixed_c.append(False)
if all(flavors_fixed_d):
shapes_fixed_d.append(True)
else:
shapes_fixed_d.append(False)
if all(shapes_fixed_c):
for shape in parameters:
for flavor in parameters[shape]:
del parameters[shape][flavor]['c']
print('parameter c is fixed for shape %s' % shape)
if all(shapes_fixed_d):
for shape in parameters:
for flavor in parameters[shape]:
del parameters[shape][flavor]['d']
print('parameter d is fixed for shape %s' % shape)
print
checkdir('%s/data' % wdir)
if Q2 == conf['Q20']:
save(parameters, '%s/data/ppdf-parameters-%d.dat' % (wdir, istep))
else:
save(parameters,
'%s/data/ppdf-parameters-%d-%f.dat' % (wdir, istep, Q2))
def get_moments(wdir, flavors, x_1, x_2, Q2=None):
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
## 'conf' will be modified for each replica individually later in the loop over 'replicas'
## the reason for doing this is that 'fix parameters' has to be set correctly for each replica
if 'ppdf' not in conf['steps'][istep]['active distributions']:
print('ppdf-proton not in active distribution')
return
resman = RESMAN(nworkers=1, parallel=False, datasets=False)
parman = resman.parman
parman.order = replicas[0]['order'][istep]
## make sure 'parman' uses the same order for active distributions as all the replicas do
# print parman.order
ppdf = conf['ppdf']
## setup kinematics
# X = 10.0 ** np.linspace(-3, -1, 100)
# X = np.append(X, np.linspace(0.1, 0.99, 100))
if Q2 == None: Q2 = conf['Q20']
print('\ngenerating momentus for polarized pdf-proton from %s at Q2 = %f' %
(wdir, Q2))
## compute moments for all replicas
moments = {}
statistics = {}
n_replicas = len(replicas)
for i in range(n_replicas):
lprint('%d/%d' % (i + 1, n_replicas))
parman.order = copy.copy(replicas[i]['order'][istep])
core.mod_conf(istep, replicas[i])
parman.set_new_params(replicas[i]['params'][istep], initial=True)
for flavor in flavors:
if flavor not in moments: moments[flavor] = []
if flavor not in statistics: statistics[flavor] = {}
if flavor == 'up':
func = lambda x: (ppdf.get_xF(x, Q2, 'u') + ppdf.get_xF(
x, Q2, 'ub')) / x
elif flavor == 'dp':
func = lambda x: (ppdf.get_xF(x, Q2, 'd') + ppdf.get_xF(
x, Q2, 'sb')) / x
elif flavor == 'sp':
func = lambda x: (ppdf.get_xF(x, Q2, 's') + ppdf.get_xF(
x, Q2, 'sb')) / x
else:
func = lambda x: ppdf.get_xF(x, Q2, flavor) / x
moments[flavor].append(quad(func, x_1, x_2)[0])
for flavor in flavors:
statistics[flavor]['mean'] = np.mean(moments[flavor])
statistics[flavor]['standard_deviation'] = np.std(moments[flavor])
print
for flavor in flavors:
print flavor, ': ', statistics[flavor]
checkdir('%s/data' % wdir)
if Q2 == conf['Q20']:
save({
'Q2': Q2,
'moments': moments,
'statistics': statistics
}, '%s/data/ppdf-moments-%s-to-%s-%d.dat' % (wdir, x_1, x_2, istep))
else:
save({
'Q2': Q2,
'moments': moments,
'statistics': statistics
}, '%s/data/ppdf-moments-%s-to-%s-%d-%f.dat' %
(wdir, x_1, x_2, istep, Q2))
def gen_xf(wdir, flavors, Q2=None):
load_config('%s/input.py' % wdir)
istep = core.get_istep()
replicas = core.get_replicas(wdir)
## 'conf' will be modified for each replica individually later in the loop over 'replicas'
## the reason for doing this is that 'fix parameters' has to be set correctly for each replica
if 'ppdf' not in conf['steps'][istep]['active distributions']:
print('ppdf-proton not in active distribution')
return
resman = RESMAN(nworkers=1, parallel=False, datasets=False)
parman = resman.parman
parman.order = replicas[0]['order'][istep]
## make sure 'parman' uses the same order for active distributions as all the replicas do
# print parman.order
ppdf = conf['ppdf']
## setup kinematics
xs = 10.0**np.linspace(-3, -1, 100)
xs = np.append(xs, np.linspace(0.1, 0.99, 100))
if Q2 == None: Q2 = conf['Q20']
print('\ngenerating polarized pdf-proton from %s at Q2 = %f' % (wdir, Q2))
## compute xf for all replicas
xfs = {}
n_replicas = len(replicas)
for i in range(n_replicas):
lprint('%d/%d' % (i + 1, n_replicas))
## filter
#flag=False
#params=replica['params'][istep]
#order=replica['order'][istep]
#for i in range(len(order)):
# if order[i][0]!=1:continue
# if order[i][1]!='ppdf':continue
# #if order[i][2]=='s1 a':
# # if params[i]<-0.9: flag=True
#if flag: continue
parman.order = copy.copy(replicas[i]['order'][istep])
core.mod_conf(istep, replicas[i])
parman.set_new_params(replicas[i]['params'][istep], initial=True)
for flavor in flavors:
if flavor not in xfs: xfs[flavor] = []
if flavor == 'up':
func = lambda x: ppdf.get_xF(x, Q2, 'u') + ppdf.get_xF(
x, Q2, 'ub')
elif flavor == 'dp':
func = lambda x: ppdf.get_xF(x, Q2, 'd') + ppdf.get_xF(
x, Q2, 'sb')
elif flavor == 'sp':
func = lambda x: ppdf.get_xF(x, Q2, 's') + ppdf.get_xF(
x, Q2, 'sb')
else:
func = lambda x: ppdf.get_xF(x, Q2, flavor)
xfs[flavor].append([func(x) for x in xs])
print
checkdir('%s/data' % wdir)
if Q2 == conf['Q20']:
save({
'X': xs,
'Q2': Q2,
'XF': xfs
}, '%s/data/ppdf-%d.dat' % (wdir, istep))
else:
save({
'X': xs,
'Q2': Q2,
'XF': xfs
}, '%s/data/ppdf-%d-%f.dat' % (wdir, istep, Q2))
