def __init__(self, name, tag, purpose, id, nmax, refname, reftag, refmem):
self.name = name
self.tag = tag
self.purpose = purpose
self.id = id
self.pdf = lhapdf.mkPDFs(self.name)
self.nmem = min(len(self.pdf), nmax) if nmax > 0 else len(self.pdf)
self.wghts = std.vector('double')()
self.wghts.resize(self.nmem)
self.wghtsalphas = std.vector('double')()
self.wghtsalphas.resize(self.nmem)
self.refname = refname
self.reftag = reftag
self.refmem = refmem
self.refpdf = lhapdf.mkPDFs(self.refname)[self.refmem]
def __init__(self,name,tag,purpose,id,nmax,refname,reftag,refmem):
self.name = name
self.tag = tag
self.purpose = purpose
self.id = id
self.pdf = lhapdf.mkPDFs(self.name)
self.nmem = min(len(self.pdf),nmax) if nmax>0 else len(self.pdf)
self.wghts = std.vector('double')()
self.wghts.resize(self.nmem)
self.wghtsalphas = std.vector('double')()
self.wghtsalphas.resize(self.nmem)
self.refname = refname
self.reftag = reftag
self.refmem = refmem
self.refpdf = lhapdf.mkPDFs(self.refname)[self.refmem]
def set_pdf(self,refer,target):
##--set LHAPDF path
lhapdf.pathsPrepend("/home/taebh/2021_Research/share/LHAPDF")
self.nnpdf = lhapdf.mkPDF(refer,0)
self.PDFsets = lhapdf.mkPDFs(target)
self.numPDF = len(self.PDFsets)
def get_pdf(pdfset, parton, q, xs):
"""get the PDF (xfx) for a certain set, parton, x and Q"""
pdfs = lhapdf.mkPDFs(pdfset)
pdf = np.zeros((len(pdfs), len(xs)))
for i_member, pdfmember in enumerate(pdfs):
for (i, xi) in enumerate(xs):
if parton < 7:
pdf[i_member - 1][i] = pdfmember.xfxQ(parton, xi, q)
elif parton == 7:
#DVAL 1-(-1)
pdf[i_member - 1][i] = pdfmember.xfxQ(1, xi, q) - \
pdfmember.xfxQ(-1, xi, q)
elif parton == 8:
#UVAL 2-(-2)
pdf[i_member - 1][i] = pdfmember.xfxQ(2, xi, q) - \
pdfmember.xfxQ(-2, xi, q)
elif parton == 9:
#Light sea: xS=2(xubar + xdbar + xsbar)
pdf[i_member - 1][i] = 2*(pdfmember.xfxQ(-1, xi, q) + \
pdfmember.xfxQ(-2, xi, q) + \
pdfmember.xfxQ(-3, xi, q))
else:
raise ValueError('Parton id not in range 0...9')
return pdf
def d2calc(interface='JAMLIB'):
if interface=='JAMLIB':
jamlib=JAMLIB('JAM15/T3PPDF')
npos = jamlib.npos
first = 0
elif interface=='LHAPDF':
jamlib=lhapdf.mkPDFs("JAM15_T3PPDF_Ceven")
npos = 200
first = 1
def _get_d2(i,Q2,nucleon):
if interface=='JAMLIB':
Du=lambda x: jamlib.get_XF(i,'up',x,Q2)/x
Dd=lambda x: jamlib.get_XF(i,'dp',x,Q2)/x
elif interface=='LHAPDF':
Du=lambda x: jamlib[i].xfxQ2(902,x,Q2)/x
Dd=lambda x: jamlib[i].xfxQ2(901,x,Q2)/x
if nucleon=='proton':
D=lambda x: 4/9.*Du(x) + 1/9.*Dd(x)
if nucleon=='neutron':
D=lambda x: 1/9.*Du(x) + 4/9.*Dd(x)
return 2*quad(lambda x: x**2*D(x),0,1)[0]
def get_d2(Q2,nucleon):
d2=[_get_d2(i+first,Q2,nucleon) for i in range(npos)]
d2=[_d2 for _d2 in d2 if np.isnan(_d2)==False]
return np.mean(d2),np.var(d2)**0.5
Q2=np.arange(1,2,0.1)
Q2=np.append(Q2,np.arange(2,3,0.2))
Q2=np.append(Q2,np.arange(3,6.5,0.5))
d2p=[get_d2(_Q2,'proton') for _Q2 in Q2]
d2n=[get_d2(_Q2,'neutron') for _Q2 in Q2]
def get_pdf(pdfset, parton, q, xs):
"""get the PDF (xfx) for a certain set, parton, x and Q"""
pdfs = lhapdf.mkPDFs(pdfset)
pdf = np.zeros((len(pdfs), len(xs)))
for i_member, pdfmember in enumerate(pdfs):
for (i, xi) in enumerate(xs):
if parton < 7:
pdf[i_member - 1][i] = pdfmember.xfxQ(parton, xi, q)
elif parton == 7:
#DVAL 1-(-1)
pdf[i_member - 1][i] = pdfmember.xfxQ(1, xi, q) - \
pdfmember.xfxQ(-1, xi, q)
elif parton == 8:
#UVAL 2-(-2)
pdf[i_member - 1][i] = pdfmember.xfxQ(2, xi, q) - \
pdfmember.xfxQ(-2, xi, q)
elif parton == 9:
#Light sea: xS=2(xubar + xdbar + xsbar)
pdf[i_member - 1][i] = 2*(pdfmember.xfxQ(-1, xi, q) + \
pdfmember.xfxQ(-2, xi, q) + \
pdfmember.xfxQ(-3, xi, q))
else:
raise ValueError('Parton id not in range 0...9')
return pdf
def __init__(self,name,central_only=False,ismc=False):
print 'loading ',name
self.name=name
self.ismc=ismc
self.central_only=central_only
if central_only==True:
self.central=lhapdf.mkPDF(name,0)
else:
self.SETS=lhapdf.mkPDFs(name)
def __init__(self,name,X=[None],central_only=False):
self.name=name
self.central_only=central_only
if central_only==True:
self.central=lhapdf.mkPDF(name,0)
else:
self.SETS=lhapdf.mkPDFs(name)
if X[0]==None: self.X=np.linspace(1e-3,0.99,1000)
else: self.X=X
def __init__(self, pdf_name, xgrid, fl, Q):
self.pdf_name = pdf_name
self.pdf = lhapdf.mkPDFs(pdf_name)
self.n_rep = len(self.pdf) - 1
self.fl = fl
self.xgrid = xgrid
self.xfxQ = np.zeros(shape=(self.n_rep, fl.n, xgrid.n))
# load replicas at Q
self.setQ(Q)
def getPdfSets():
pdfNames = [
"CT10", "CT10nnlo_as_0117", "CT10nnlo_as_0119", "MSTW2008nnlo68cl",
"MSTW2008nnlo68cl_asmz-68cl", "MSTW2008nnlo68cl_asmz+68cl",
"NNPDF23_nnlo_as_0116", "NNPDF23_nnlo_as_0117", "NNPDF23_nnlo_as_0118",
"NNPDF23_nnlo_as_0119", "NNPDF23_nnlo_as_0120", "NNPDF23_nnlo_as_0121",
"NNPDF23_nnlo_as_0122"
]
out = {}
for name in pdfNames:
out[name] = lhapdf.mkPDFs(name)
return out
def gen_hess_glue(Q2=2.0):
X = 10**np.linspace(-4, -1, 100)
X = np.append(X, np.linspace(0.1, 0.99, 100))
data = {'X': X, 'Q2': Q2}
pdfs = lhapdf.mkPDFs(fname)
for i in range(len(pdfs)):
data[i] = np.array([pdfs[i].xfxQ2(21, x, Q2) for x in X])
err2 = np.zeros(data[0].size)
for iset in range(1, len(pdfs), 2):
err2 += (data[iset] - data[iset + 1])**2 / 4.0
data['err'] = err2**0.5
save(data, 'data/hess_glue_%.2f.po' % Q2)
def getPdfSets():
pdfNames = [
"CT10",
"CT10nnlo_as_0117",
"CT10nnlo_as_0119",
"MSTW2008nnlo68cl",
"MSTW2008nnlo68cl_asmz-68cl",
"MSTW2008nnlo68cl_asmz+68cl",
"NNPDF23_nnlo_as_0116",
"NNPDF23_nnlo_as_0117",
"NNPDF23_nnlo_as_0118",
"NNPDF23_nnlo_as_0119",
"NNPDF23_nnlo_as_0120",
"NNPDF23_nnlo_as_0121",
"NNPDF23_nnlo_as_0122"
]
out = {}
for name in pdfNames:
out[name] = lhapdf.mkPDFs( name )
return out
def gen_dist_from_lhapdf(wdir,dist,dirname):
print('\ngenerating %s tables for benchmark using %s from lhapdf'%(dist,wdir))
replicas=lhapdf.mkPDFs(dirname)
X,Q2=gen_grid(dist)
flavs=[-5,-4,-3,-2,-1,1,2,3,4,5,21]
#--gen qpd data per replica
checkdir('%s/benchmark'%wdir)
cnt=0
for i in range(len(replicas)):
lprint('progress: %d/%d'%(cnt+1,len(replicas)))
replica=replicas[i]
data={}
for _ in Q2:
data[_]={}
for flav in flavs:
data[_][flav]=np.array([replica.xfxQ2(flav,x,_) for x in X])
save(data,'%s/benchmark/%s-%d-lha.dat'%(wdir,dist,cnt))
cnt+=1
print
def build_pdf(self):
"""Construct a grid of PDF from a grid in x depenging on
the input parameters.
Returns
-------
result: array_like
PDF grid of shape=(replicas, flavours, x-grid)
"""
# Call lhapdf PDF set PDF set
pdf = lhapdf.mkPDFs(self.pdf_name)
pdf_size = len(pdf)
xgrid_size = self.xgrid.shape[0]
# construct input pdf replicas
inpdf = np.zeros((pdf_size, 2 * self.nf + 1, xgrid_size))
for p in range(pdf_size):
for f in range(-self.nf, self.nf + 1):
for x in range(xgrid_size):
inpdf[p][f + self.nf][x] = pdf[p].xfxQ(
f, self.xgrid[x], self.q_value)
return inpdf
def __init__(self,name):
self.name=name
self.SETS=lhapdf.mkPDFs(name)
p = lhapdf.mkPDF("CT10", 0)
p = lhapdf.mkPDF("CT10/0")
## Gluon PDF querying at x=0.001, Q2=10000
print p.xfxQ2(21, 1e-3, 1e4)
## Basic all-flavour PDF querying at x=0.01, Q=M_Z
for pid in p.flavors():
print p.xfxQ(pid, 0.01, 91.2)
# TODO: demonstrate looping over PDF set members
pset = lhapdf.getPDFSet("CT10nlo")
print pset.description
pcentral = pset.mkPDF(0)
pdfs1 = pset.mkPDFs()
pdfs2 = lhapdf.mkPDFs("CT10nlo") # a direct way to get all the set's PDFs
## Filling a numpy 2D array with xf(x,Q) samples
import numpy as np
xs = [x for x in np.logspace(-7, 0, 5)]
qs = [q for q in np.logspace(1, 4, 4)]
gluon_xfs = np.empty([len(xs), len(qs)])
for ix, x in enumerate(xs):
for iq, q in enumerate(qs):
gluon_xfs[ix,iq] = p.xfxQ(21, x, q)
print gluon_xfs
## Version info, search paths, and metadata
print lhapdf.version()
print lhapdf.__version__
lhapdf.pathsPrepend("/path/to/extra/pdfsets")
def __init__(self, pdf_name, q_value, nf):
self.nf = nf
self.q_value = q_value
self.pdf_name = pdf_name
self.lhpdf = lhapdf.mkPDFs(pdf_name)
p = lhapdf.mkPDF("CT10", 0)
p = lhapdf.mkPDF("CT10/0")
## Gluon PDF querying at x=0.001, Q2=10000
print(p.xfxQ2(21, 1e-3, 1e4))
## Basic all-flavour PDF querying at x=0.01, Q=M_Z
for pid in p.flavors():
print(p.xfxQ(pid, 0.01, 91.2))
# TODO: demonstrate looping over PDF set members
pset = lhapdf.getPDFSet("CT10nlo")
print(pset.description)
pcentral = pset.mkPDF(0)
pdfs1 = pset.mkPDFs()
pdfs2 = lhapdf.mkPDFs("CT10nlo") # a direct way to get all the set's PDFs
## Filling a numpy 2D array with xf(x,Q) samples
import numpy as np
xs = [x for x in np.logspace(-7, 0, 5)]
qs = [q for q in np.logspace(1, 4, 4)]
gluon_xfs = np.empty([len(xs), len(qs)])
for ix, x in enumerate(xs):
for iq, q in enumerate(qs):
gluon_xfs[ix, iq] = p.xfxQ(21, x, q)
print(gluon_xfs)
## Version info, search paths, and metadata
print(lhapdf.version())
print(lhapdf.__version__)
lhapdf.pathsPrepend("/path/to/extra/pdfsets")
def main():
args = arg_parser()
compressed_file = args.infile
# Reading results from file
with open(compressed_file) as results_file:
results = json.load(results_file)
pdfset_name = results["pdfset_name"]
index = results["index"] # Array of index
nbcomp = len(index)
# Get LHAPDF datadir
lhapdf_dir = Popen(["lhapdf-config", "--datadir"], stdout=PIPE)
pdf_dir, _ = lhapdf_dir.communicate()
pdf_dir = pdf_dir.decode("utf-8")
pdf_dir = pdf_dir.replace("\n", "")
# Create output file
output = pdfset_name + "_compressed_" + str(nbcomp)
# Create Output folders
if not os.path.exists(output):
os.mkdir(output)
else:
pass
src_str = pdf_dir + "/" + pdfset_name + "/" + pdfset_name
dst_str = output + "/" + output
# Copy the LHAPDF replicas to the output file
cindex = []
console.print("\n• Copying the selected replicas to compressed set:",
style="bold blue")
with trange(nbcomp) as iter_index:
for ix, idx in enumerate(iter_index):
indx = int(index[idx]) # Make sure it's an integer
cindex.append(indx)
# Extension name corresponding to the prior
# Number of PDF replicas < 10000
if indx < 10:
ext_name_prior = "000" + str(indx)
elif indx < 100:
ext_name_prior = "00" + str(indx)
elif indx < 1000:
ext_name_prior = "0" + str(indx)
else:
ext_name_prior = str(indx)
# Extension name for Compressed replicas
if (ix + 1) < 10:
ext_name_compress = "000" + str(ix + 1)
elif (ix + 1) < 100:
ext_name_compress = "00" + str(ix + 1)
elif (ix + 1) < 1000:
ext_name_compress = "0" + str(ix + 1)
else:
ext_name_compress = str(ix + 1)
# Construc path name
src = src_str + "_" + ext_name_prior + ".dat"
dst = dst_str + "_" + ext_name_compress + ".dat"
# copy srouce to compressed
shutil.copy(src, dst)
iter_index.set_description(
f"copy original_{indx} to compressed_{ix+1}")
# Construct .info file for compressed set
src = src_str + ".info"
dst = dst_str + ".info"
src_file = open(src, "r")
dst_file = open(dst, "w")
for line in src_file.readlines():
if "NumMembers:" in line:
dst_file.write("NumMembers: " + str(nbcomp + 1) + "\n")
else:
dst_file.write(line)
dst_file.close()
src_file.close()
# Fetching info from Prior Central PDF
console.print("\n• Fetching information from original central PDF.",
style="bold blue")
w = open(src_str + "_0000.dat", "r")
xpdf = []
xgrid, qgrid, fgrid = [], [], []
textxs, textqs, textfs = [], [], []
# Removing the info in the head
for _ in range(0, 10):
if "--" in w.readline():
break
# Init grid size count
s = 0
table = Table(show_header=True, header_style="bold magenta")
table.add_column("N", justify="left")
table.add_column("Subgrids", justify="center", width=35)
while True:
textxs.append(w.readline())
xs = [float(el) for el in textxs[s].split()]
textqs.append(w.readline())
qs = [float(el) for el in textqs[s].split()]
textfs.append(w.readline())
fs = [int(float(el)) for el in textfs[s].split()]
if len(xs) == 0:
break
xgrid.append(xs)
qgrid.append(qs)
fgrid.append(fs)
nx = len(xgrid[s])
nq = len(qgrid[s])
table.add_row(f"{s}",
f"{len(xgrid[s])} {len(qgrid[s])} {len(fgrid[s])}")
for ix in range(0, nx):
for iq in range(0, nq):
w.readline().split()
w.readline()
s += 1
w.close()
console.print(table)
# Reading XPDF
console.print("\n• Extract grid information from compressed set:",
style="bold blue")
pdf = lhapdf.mkPDFs(pdfset_name)
with trange(len(cindex)) as iter_index:
for irep in iter_index:
iter_index.set_description(f"Reading Replica {irep}")
xpdf.append([])
for ss in range(s):
xpdf[irep].append([])
for ix in range(len(xgrid[ss])):
xpdf[irep][ss].append([])
for iq in range(len(qgrid[ss])):
xpdf[irep][ss][ix].append([])
for ifl in range(len(fgrid[ss])):
xfq_result = pdf[cindex[irep]].xfxQ(
fgrid[ss][ifl], xgrid[ss][ix], qgrid[ss][iq])
if math.isnan(xfq_result): xfq_result = 0
xpdf[irep][ss][ix][iq].append(xfq_result)
# Construct commpressed central PDF
console.print("\n• Computing central replicas.", style="bold blue")
w = open(dst_str + "_0000.dat", "w")
w.write("PdfType: central\n")
w.write("Format: lhagrid1\n---\n")
for ss in range(s):
w.write(textxs[ss])
w.write(textqs[ss])
w.write(textfs[ss])
for ix in range(len(xgrid[ss])):
for iq in range(len(qgrid[ss])):
w.write(" ")
for ifl in range(len(fgrid[ss])):
sum = 0
for irep in range(len(cindex)):
sum += xpdf[irep][ss][ix][iq][ifl]
sum /= nbcomp
print("%14.7E" % sum, end=' ', file=w)
w.write("\n")
w.write("---\n")
w.close()
def lhapdf_xfs(pdf_name, xs, flavors, Q2):
pdf_information = lhapdf.getPDFSet(pdf_name)
n_xs = len(xs)
Q = np.sqrt(Q2)
if (pdf_information.errorType == 'hessian') or (pdf_information.errorType
== 'symmhessian'):
## 'lhapdf.getPDFSet("ABMP16_3_nlo").errorType' is 'symmhessian'
pdf_0 = lhapdf.mkPDF(pdf_name, 0)
xfs = {}
for flavor in flavors:
xfs[flavor] = {
'center': np.zeros(n_xs),
'difference': np.zeros(n_xs)
}
for i in range(1, ((pdf_information.size - 1) / 2) + 1):
pdf_plus = lhapdf.mkPDF(pdf_name, 2 * i)
pdf_minus = lhapdf.mkPDF(pdf_name, 2 * i - 1)
for j in range(n_xs):
for flavor in flavors:
if flavor == 'uv':
xfs[flavor]['center'][j] = pdf_0.xfxQ(
2, xs[j], Q) - pdf_0.xfxQ(-2, xs[j], Q)
xfs[flavor]['difference'][j] += (
pdf_plus.xfxQ(2, xs[j], Q) -
pdf_plus.xfxQ(-2, xs[j], Q) -
(pdf_minus.xfxQ(2, xs[j], Q) -
pdf_minus.xfxQ(-2, xs[j], Q)))**2.0
elif flavor == 'dv':
xfs[flavor]['center'][j] = pdf_0.xfxQ(
1, xs[j], Q) - pdf_0.xfxQ(-1, xs[j], Q)
xfs[flavor]['difference'][j] += (
pdf_plus.xfxQ(1, xs[j], Q) -
pdf_plus.xfxQ(-1, xs[j], Q) -
(pdf_minus.xfxQ(1, xs[j], Q) -
pdf_minus.xfxQ(-1, xs[j], Q)))**2.0
elif flavor == 'u':
xfs[flavor]['center'][j] = pdf_0.xfxQ(2, xs[j], Q)
xfs[flavor]['difference'][j] += (
pdf_plus.xfxQ(2, xs[j], Q) -
pdf_minus.xfxQ(2, xs[j], Q))**2.0
elif flavor == 'd':
xfs[flavor]['center'][j] = pdf_0.xfxQ(1, xs[j], Q)
xfs[flavor]['difference'][j] += (
pdf_plus.xfxQ(1, xs[j], Q) -
pdf_minus.xfxQ(1, xs[j], Q))**2.0
elif flavor == 'd/u':
xfs[flavor]['center'][j] = pdf_0.xfxQ(
1, xs[j], Q) / pdf_0.xfxQ(2, xs[j], Q)
xfs[flavor]['difference'][j] += (
(pdf_plus.xfxQ(1, xs[j], Q) -
pdf_minus.xfxQ(1, xs[j], Q)) /
pdf_0.xfxQ(2, xs[j], Q))**2.0
elif flavor == 'db+ub':
xfs[flavor]['center'][j] = pdf_0.xfxQ(
-1, xs[j], Q) + pdf_0.xfxQ(-2, xs[j], Q)
xfs[flavor]['difference'][j] += (
pdf_plus.xfxQ(-1, xs[j], Q) +
pdf_plus.xfxQ(-2, xs[j], Q) -
(pdf_minus.xfxQ(-1, xs[j], Q) +
pdf_minus.xfxQ(-2, xs[j], Q)))**2.0
elif flavor == 'db-ub':
xfs[flavor]['center'][j] = pdf_0.xfxQ(
-1, xs[j], Q) - pdf_0.xfxQ(-2, xs[j], Q)
xfs[flavor]['difference'][j] += (
pdf_plus.xfxQ(-1, xs[j], Q) -
pdf_plus.xfxQ(-2, xs[j], Q) -
(pdf_minus.xfxQ(-1, xs[j], Q) -
pdf_minus.xfxQ(-2, xs[j], Q)))**2.0
elif flavor == 's+sb':
xfs[flavor]['center'][j] = pdf_0.xfxQ(
3, xs[j], Q) + pdf_0.xfxQ(-3, xs[j], Q)
xfs[flavor]['difference'][j] += (
pdf_plus.xfxQ(3, xs[j], Q) +
pdf_plus.xfxQ(-3, xs[j], Q) -
(pdf_minus.xfxQ(3, xs[j], Q) +
pdf_minus.xfxQ(-3, xs[j], Q)))**2.0
elif flavor == 'g':
xfs[flavor]['center'][j] = pdf_0.xfxQ(21, xs[j], Q)
xfs[flavor]['difference'][j] += (
pdf_plus.xfxQ(21, xs[j], Q) -
pdf_minus.xfxQ(21, xs[j], Q))**2.0
elif flavor == 'rs':
if pdf_name == 'CJ15nlo':
## R_s is set to be 0.4 in CJ15
xfs[flavor]['center'][j] = 0.4
xfs[flavor]['difference'][j] += 0.0
else:
xfs[flavor]['center'][j] = (pdf_0.xfxQ(
3, xs[j], Q) + pdf_0.xfxQ(-3, xs[j], Q)) / (
pdf_0.xfxQ(-1, xs[j], Q) +
pdf_0.xfxQ(-2, xs[j], Q))
xfs[flavor]['difference'][j] += ((pdf_plus.xfxQ(3, xs[j], Q) + pdf_plus.xfxQ(-3, xs[j], Q) - (pdf_minus.xfxQ(3, xs[j], Q) + pdf_minus.xfxQ(-3, xs[j], Q))) / \
(pdf_0.xfxQ(-1, xs[j], Q) + pdf_0.xfxQ(-2, xs[j], Q))) ** 2.0
for flavor in flavors:
xfs[flavor]['difference'] = 0.5 * np.sqrt(
xfs[flavor]['difference'])
elif pdf_information.errorType == 'replicas':
pdf_all = lhapdf.mkPDFs(pdf_name)
xfs = {}
xfs_temp = {}
for flavor in flavors:
xfs[flavor] = {'center': [], 'difference': []}
for i in range(n_xs):
for flavor in flavors:
xfs_temp[flavor] = []
for pdf_individual in pdf_all:
for flavor in flavors:
if flavor == 'uv':
xfs_temp[flavor].append(
pdf_individual.xfxQ(2, xs[i], Q) -
pdf_individual.xfxQ(-2, xs[i], Q))
elif flavor == 'dv':
xfs_temp[flavor].append(
pdf_individual.xfxQ(1, xs[i], Q) -
pdf_individual.xfxQ(-1, xs[i], Q))
elif flavor == 'u':
xfs_temp[flavor].append(
pdf_individual.xfxQ(2, xs[i], Q))
elif flavor == 'd':
xfs_temp[flavor].append(
pdf_individual.xfxQ(1, xs[i], Q))
elif flavor == 'd/u':
xfs_temp[flavor].append(
pdf_individual.xfxQ(1, xs[i], Q) /
pdf_individual.xfxQ(2, xs[i], Q))
elif flavor == 'db+ub':
xfs_temp[flavor].append(
pdf_individual.xfxQ(-1, xs[i], Q) +
pdf_individual.xfxQ(-2, xs[i], Q))
elif flavor == 'db-ub':
xfs_temp[flavor].append(
pdf_individual.xfxQ(-1, xs[i], Q) -
pdf_individual.xfxQ(-2, xs[i], Q))
elif flavor == 's+sb':
xfs_temp[flavor].append(
pdf_individual.xfxQ(3, xs[i], Q) +
pdf_individual.xfxQ(-3, xs[i], Q))
elif flavor == 'g':
xfs_temp[flavor].append(
pdf_individual.xfxQ(21, xs[i], Q))
elif flavor == 'rs':
xfs_temp[flavor].append(
(pdf_individual.xfxQ(3, xs[i], Q) +
pdf_individual.xfxQ(-3, xs[i], Q)) /
(pdf_individual.xfxQ(-1, xs[i], Q) +
pdf_individual.xfxQ(-2, xs[i], Q)))
for flavor in flavors:
xfs[flavor]['center'].append(np.mean(xfs_temp[flavor], axis=0))
xfs[flavor]['difference'].append(
np.std(xfs_temp[flavor], axis=0))
for flavor in flavors:
xfs[flavor]['center'] = np.array(xfs[flavor]['center'])
xfs[flavor]['difference'] = np.array(xfs[flavor]['difference'])
return xfs
##--get generator information
id1 = events["Events"].array("pdg1")
x1 = events["Events"].array("x1")
id2 = events["Events"].array("pdg2")
x2 = events["Events"].array("x2")
xpdf1 = events["Events"].array("xpdf1")
xpdf2 = events["Events"].array("xpdf2")
Q = events["Events"].array("scalePDF")
##--set LHAPDF path
lhapdf.pathsPrepend("/home/taebh/2021_Research/share/LHAPDF")
numEvents = len(id1)
nnpdf = lhapdf.mkPDF("NNPDF31_nnlo_as_0118_mc_hessian_pdfas", 0)
PDFsets = lhapdf.mkPDFs("CT18NNLO")
numPDF = len(PDFsets)
reweight = np.empty([numPDF])
for j in range(numPDF):
sumw = 0
ct18 = PDFsets[j]
for i in range(numEvents):
sumw += (ct18.xfxQ(id1[i], x1[i], Q[i]) * ct18.xfxQ(
id2[i], x2[i], Q[i])) / (nnpdf.xfxQ(id1[i], x1[i], Q[i]) *
nnpdf.xfxQ(id2[i], x2[i], Q[i]))
reweight[j] = sumw / numEvents
a = np.square(reweight[1:] - reweight[0])
PDFuncert = math.sqrt(a.sum())
#! /usr/bin/env python
import sys
PDF = "CT14nnlo"
PID = 0
if len(sys.argv) > 1:
PDF = sys.argv[1]
if len(sys.argv) > 2:
PID = int(sys.argv[2])
import lhapdf
pdfs = lhapdf.mkPDFs(PDF)
import pylab as pl
xs = pl.append(pl.exp(pl.linspace(pl.log(1e-5), pl.log(0.1))),
pl.linspace(0.1, 1.0))
#print xs
p0 = pl.array([pdfs[0].xfxQ(PID, x, 100) for x in xs])
p1 = pl.array([pdfs[1].xfxQ(PID, x, 100) for x in xs])
r10 = p1 / p0
print r10
# p2 = array([pdfs[2].xfxQ(PID,x,100) for x in xs])
# r20 = p2/p0
# plot(xs, r10, label="EV1/Nom")
# plot(xs, r20, label="EV2/Nom")
for i in range(1, len(pdfs)):
pl.plot(xs,
pl.array([pdfs[i].xfxQ(PID, x, 100) for x in xs]) / p0,
label="EV{:d}/Nom".format(i))
import sys,os
sys.path.insert(1,'../../')
import numpy as np
import pylab as py
import tools
from tools import tex,plot_band,fill_between
import lhapdf
import matplotlib.gridspec as gridspec
from matplotlib import rc
rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})
rc('text',usetex=True)
from master import FITPACK
# initialize PDF instances
HERA15=lhapdf.mkPDFs('HERAPDF15LO_EIG')
MMHT14=lhapdf.mkPDFs('MMHT2014lo68cl')
MSTW08=lhapdf.mkPDFs('MSTW2008lo68cl')
# dictionary for pdg flav idx
pdgmap= {'u':2,'d':1,'ub':-2,'db': -1,'s':3,'g':21}
# simple function to access lhad pdfs
get_pdfs = lambda flav,x,Q2,iset,grp: grp[iset].xfxQ2(pdgmap[flav],x,Q2)
# load CJ15 from fitpack data
fname='data/CDBONN_KP_1_LO_6.pdf'
CJ15=FITPACK().get_PDFs(fname)
# dictionary for labels
labmap = {}
def plot2(Q2=2.0):
hess = load('data/hess_glue_%.2f.po' % Q2)
mc = load('data/mcglue_%.2f.po' % Q2)
ncols, nrows = 1, 1
py.figure(figsize=(ncols * 5, nrows * 4))
ax = py.subplot(nrows, ncols, 1)
X = hess['X']
ct14 = lhapdf.mkPDFs('CT14nlo')
denom = np.array([ct14[0].xfxQ2(21, x, Q2) for x in X])
#--plot current errorbands (hess version)
ax.fill_between(X, (hess[0] - hess['err']) / denom,
(hess[0] + hess['err']) / denom,
color='Y',
alpha=0.5,
label=r'$\rm EPPS16$')
#--plot current errorbands (mc version)
#g = np.mean(mc,axis=0)
#dg = np.std(mc,axis=0)
#ax.fill_between(X,(g-dg)/denom
# ,(g+dg)/denom
# ,facecolor='none',hatch='//',edgecolor='k')
#--plot mc reweighted errorbands
weights = load('data/weights.po')
g = np.sum([weights[i] * mc[i] for i in range(weights.size)], axis=0)
dg = np.sum([weights[i] * (mc[i] - g)**2 for i in range(weights.size)],
axis=0)**0.5
ax.fill_between(X, (g - dg) / denom, (g + dg) / denom,
facecolor='r',
alpha=0.8,
label=r'$\rm EPPS16+EIC$')
##--plot eic kinematics
#t=pd.read_excel('expdata/eic.xlsx')
#xmin=np.amin(t.X)
#xmax=np.amax(t.X)
#ax.plot([xmin,xmax],[0.25,0.25],'g-',lw=5)
#ax.text(0.3,0.15,r'$\rm EIC~kinematics$',size=10,transform=ax.transAxes)
#--grids prop
ax.axhline(1, color='k', ls=':')
ax.set_ylim(0, 2)
ax.set_xlim(1e-2, 0.9)
ax.semilogx()
ax.set_yticks([0, 0.5, 1, 1.5, 2])
ax.set_xticks([0.01, 0.1])
ax.set_xticklabels([r'$0.01$', r'$0.1$'])
ax.text(0.05,
0.9,
r'$\mu^2=2{~\rm GeV^2}$',
size=15,
transform=ax.transAxes)
ax.text(0.05, 0.8, r'$A=56$', size=15, transform=ax.transAxes)
ax.legend(loc=1, framealpha=1)
#--axis labels
ax.set_ylabel(r'$R_g$', size=20)
ax.set_xlabel(r'$x$', size=20)
ax.xaxis.set_label_coords(0.95, -0.03)
py.tight_layout()
checkdir('gallery')
#py.savefig('gallery/Rg.pdf')
py.savefig('gallery/Rg.png')
py.close()
