def __init__(self,spl,hadron,shape='nderiv'): self.hadron=hadron self.shape=shape self.Q20=conf['Q20'] self.mc2=conf['aux'].mc2 self.mb2=conf['aux'].mb2 self.mellin=conf['mellin'] self.kernel=KERNELS(self.mellin,spl) self.dglap=DGLAP(self.mellin,conf['alphaS'],self.kernel,'truncated','LO') self.set_default_params() self.setup() self.ford=['g','u','ub','d','db','s','sb','c','cb','b','bb']
class PDF(CORE): def __init__(self, spl, shape='nderiv'): self.shape = shape self.Q20 = conf['Q20'] self.mc2 = conf['aux'].mc2 self.mb2 = conf['aux'].mb2 self.mellin = conf['mellin'] self.kernel = KERNELS(self.mellin, spl) self.dglap = DGLAP(self.mellin, conf['alphaS'], self.kernel, 'truncated', 'LO') self.set_default_params() self.setup() self.ford = [ 'g', 'u', 'ub', 'd', 'db', 's', 'sb', 'c', 'cb', 'b', 'bb' ] def set_default_params(self): #--f(x) = norm * x**a1 * (1-x)**b1 * (1+c1*x+d1*x**2) * (1+ N2 * x**a2 * (1-x)**b2 * (1+c2*x+d2*x**2)) params = {} params['g1'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) params['uv1'] = np.array([0.25, 1., 4., 0., 0., 0., 0., 0., 0., 0.]) params['dv1'] = np.array([-0.1, 1., 6., 0., 0., 0., 0., 0., 0., 0.]) params['sea1'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) params['sea2'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) params['db1'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) params['ub1'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) params['s1'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) params['sb1'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) self.params = params #--widths self._widths1_uv = 0.3 self._widths1_dv = 0.3 self._widths1_sea = 0.3 self._widths2_uv = 0 self._widths2_dv = 0 self._widths2_sea = 0 # internal self.widths1 = np.ones(11) self.widths2 = np.ones(11) def set_sumrules(self): #--valence self.params['uv1'][0] = 1 self.params['uv1'][0] = 2 / self.get_moments('uv1', 1) self.params['dv1'][0] = 1 self.params['dv1'][0] = 1 / self.get_moments('dv1', 1) #--strange self.params['s1'][0] = 1 self.params['s1'][0] = self.get_moments('sb1', 1) / self.get_moments( 's1', 1) #--msr sea1 = self.get_moments('sea1', 2) sea2 = self.get_moments('sea2', 2) up = self.get_moments('uv1', 2) + 2 * (sea1 + self.get_moments('ub1', 2)) dp = self.get_moments('dv1', 2) + 2 * (sea1 + self.get_moments('db1', 2)) sp = (sea2 + self.get_moments('s1', 2)) + (sea2 + self.get_moments('sb1', 2)) self.params['g1'][0] = 1 self.params['g1'][0] = (1 - up - dp - sp) / self.get_moments('g1', 2) g = self.get_moments('g1', 2) msr = g + up + dp + sp #--share self.sr = {} self.sr['msr'] = msr self.sr['uv(1)'] = self.get_moments('uv1', 1) self.sr['dv(1)'] = self.get_moments('dv1', 1) self.sr['s-sb(1)'] = self.get_moments('s1', 1) - self.get_moments( 'sb1', 1) self.sr['s-sb(2)'] = self.get_moments('s1', 2) - self.get_moments( 'sb1', 2) self.sr['db-ub(1)'] = self.get_moments('db1', 1) - self.get_moments( 'ub1', 1) self.sr['db-ub(2)'] = self.get_moments('db1', 2) - self.get_moments( 'ub1', 2) #for _ in sorted(self.sr): print _, self.sr[_] def set_moms(self): sea1 = self.get_moments('sea1') sea2 = self.get_moments('sea2') moms = {} moms['g'] = self.get_moments('g1') moms['up'] = self.get_moments('uv1') + 2 * (sea1 + self.get_moments('ub1')) moms['dp'] = self.get_moments('dv1') + 2 * (sea1 + self.get_moments('db1')) moms['sp'] = 2 * sea2 + self.get_moments('s1') + self.get_moments( 'sb1') moms['um'] = self.get_moments('uv1') moms['dm'] = self.get_moments('dv1') moms['sm'] = self.get_moments('s1') - self.get_moments('sb1') self.moms0 = moms self.get_BC(moms) def set_widths(self): for i in range(11): if i == 1: self.widths1[i] = self._widths1_uv elif i == 3: self.widths1[i] = self._widths1_dv else: self.widths1[i] = self._widths1_sea for i in range(11): if i == 1: self.widths2[i] = self._widths2_uv elif i == 3: self.widths2[i] = self._widths2_dv else: self.widths2[i] = self._widths2_sea def setup(self): #self.set_sumrules() self.set_moms() self.set_widths() #--store moments of a given Q2 that has been already calculated self.storage = {} def beta(self, a, b): return gamma(a) * gamma(b) / gamma(a + b) def get_moments(self, flav, N=None): """ if N==None: then parametrization is to be used to compute moments along mellin contour else the Nth moment is returned """ if N == None: N = self.mellin.N M1, a1, b1, c1, d1, M2, a2, b2, c2, d2 = self.params[flav] n1 = self.beta(a1 + 2, b1 + 1) + c1 * self.beta( a1 + 3, b1 + 1) + d1 * self.beta(a1 + 4, b1 + 1) n2 = M2 * (self.beta(a1 + a2 + 2, b1 + b2 + 1) + d1 * d2 * self.beta(a1 + a2 + 6, b1 + b2 + 1)) n3 = M2 * (c1 + c2) * self.beta(a1 + a2 + 3, b1 + b2 + 1) n4 = M2 * (c1 * d2 + c2 * d1) * self.beta(a1 + a2 + 5, b1 + b2 + 1) n5 = M2 * (c1 * c2 + d1 + d2) * self.beta(a1 + a2 + 4, b1 + b2 + 1) norm = n1 + n2 + n3 + n4 + n5 m1 = self.beta(a1 + N, b1 + 1) + c1 * self.beta( a1 + N + 1, b1 + 1) + d1 * self.beta(a1 + N + 2, b1 + 1) m2 = M2 * (self.beta(a1 + a2 + N, b1 + b2 + 1) + d1 * d2 * self.beta(a1 + a2 + N + 4, b1 + b2 + 1)) m3 = M2 * (c1 + c2) * self.beta(a1 + a2 + N + 1, b1 + b2 + 1) m4 = M2 * (c1 * d2 + c2 * d1) * self.beta(a1 + a2 + N + 3, b1 + b2 + 1) m5 = M2 * (c1 * c2 + d1 + d2) * self.beta(a1 + a2 + N + 2, b1 + b2 + 1) mom = m1 + m2 + m3 + m4 + m5 return M1 * mom / norm #if self.shape=='nderiv': # m1 = self.beta(a1+N,b1+1) + c1*self.beta(a1+N+1,b1+1) + d1*self.beta(a1+N+2,b1+1) # m2 = M2 * (self.beta(a1+a2+N,b1+b2+1) + d1*d2*self.beta(a1+a2+N+4,b1+b2+1)) # m3 = M2 * (c1+c2)*self.beta(a1+a2+N+1,b1+b2+1) # m4 = M2 * (c1*d2+c2*d1)*self.beta(a1+a2+N+3,b1+b2+1) # m5 = M2 * (c1*c2+d1+d2)*self.beta(a1+a2+N+2,b1+b2+1) # mom=m1+m2+m3+m4+m5 # return M1*mom/norm #elif self.shape=='deriv': # m1 = a1*self.beta(a1+N-1, b1+1) - b1*self.beta(a1+N, b1) #- b1*c1*self.beta(a1+N+1, b1) - b1*d1*self.beta(a1+N+2, b1) # #m2 = (c1 + a1*c1)*self.beta(a1+N, b1+1) + (2*d1 + a1*d1)*self.beta(a1+N+1, b1+1) # #m3 = M2 * ((a1 + a2)*self.beta(a1+a2+N-1, b1+b2+1) - (b1 + b2)*self.beta(a1+a2+N, b1+b2)) # #m4 = M2 * ((c1 + a1*c1 + a2*c1 + c2 + a1*c2 + a2*c2)*self.beta(a1+a2+N, b1+b2+1)) # #m5 = M2 * (-(b1*c1 + b2*c1 + b1*c2 + b2*c2)*self.beta(a1+a2+N+1, b1+b2)) # #m6 = M2 * ((2*c1*c2 + a1*c1*c2 + a2*c1*c2 + 2*d1 + a1*d1 + a2*d1 + 2*d2 + a1*d2 + a2*d2)*self.beta(a1+a2+N+1, b1+b2+1)) # #m7 = M2 * (-(b1*c1*c2 + b2*c1*c2 + b1*d1 + b2*d1 + b1*d2 + b2*d2)*self.beta(a1+a2+N+2, b1+b2)) # #m8 = M2 * ((3*c2*d1 + a1*c2*d1 + a2*c2*d1 + 3*c1*d2 + a1*c1*d2 + a2*c1*d2)*self.beta(a1+a2+N+2, b1+b2+1)) # #m9 = M2 * (-(b1*c2*d1 + b2*c2*d1 + b1*c1*d2 + b2*c1*d2)*self.beta(a1+a2+N+3, b1+b2)) # #m10 = M2 * ((4*d1*d2 + a1*d1*d2 + a2*d1*d2)*self.beta(a1+a2+N+3, b1+b2+1)) # #m11 = M2 * (-(b1*d1*d2 + b2*d1*d2)*self.beta(a1+a2+N+4, b1+b2)) # mom=m1#+m2+m3+m4+m5+m6+m7+m8+m9+m10+m11 # return M1*mom/norm def _get_BC(self, g, up, um, dp, dm, sp, sm, cp, cm, bp, bm, tp, tm): N = self.mellin.N # flav composition vm, vp = {}, {} vm[35] = bm + cm + dm + sm - 5 * tm + um vm[24] = -4 * bm + cm + dm + sm + um vm[15] = -3 * cm + dm + sm + um vm[8] = dm - 2 * sp + 2 * (-sm + sp) + um vm[3] = -dm + um vm[0] = np.zeros(N.size, dtype=complex) vp[0] = np.zeros(N.size, dtype=complex) vp[3] = -dp + up vp[8] = dp - 2 * sp + up vp[15] = -3 * cp + dp + sp + up vp[24] = -4 * bp + cp + dp + sp + up vp[35] = bp + cp + dp + sp - 5 * tp + up qs = bp + cp + dp + sp + tp + up qv = bm + cm + dm + sm + tm + um q = np.zeros((2, N.size), dtype=complex) q[0] = np.copy(qs) q[1] = np.copy(g) BC = {} BC['vm'] = vm BC['vp'] = vp BC['qv'] = qv BC['q'] = q return BC def get_state(self): return (self.widths1, self.widths2, self.BC3, self.BC4, self.BC5) def set_state(self, state): self.widths1, self.widths2, self.BC3, self.BC4, self.BC5 = state[:] self.storage = {} def get_BC(self, moms): N = self.mellin.N zero = np.zeros(N.size, dtype=complex) ############################################### # BC for Nf=3 g = moms['g'] up = moms['up'] um = moms['um'] dp = moms['dp'] dm = moms['dm'] sp = moms['sp'] sm = moms['sm'] cp = zero cm = zero bp = zero bm = zero self.BC3 = self._get_BC(g, up, um, dp, dm, sp, sm, zero, zero, zero, zero, zero, zero) ############################################### # BC for Nf=4 BC4 = self.dglap.evolve(self.BC3, self.Q20, self.mc2, 3) g = BC4['g'] up = BC4['up'] dp = BC4['dp'] sp = BC4['sp'] cp = BC4['cp'] bp = BC4['bp'] tp = BC4['tp'] um = BC4['um'] dm = BC4['dm'] sm = BC4['sm'] cm = BC4['cm'] bm = BC4['bm'] tm = BC4['tm'] self.BC4 = self._get_BC(g, up, um, dp, dm, sp, sm, cp, cm, bp, bm, tp, tm) ############################################### # BC for Nf=5 BC5 = self.dglap.evolve(self.BC4, self.mc2, self.mb2, 4) g = BC5['g'] up = BC5['up'] dp = BC5['dp'] sp = BC5['sp'] cp = BC5['cp'] bp = BC5['bp'] tp = BC5['tp'] um = BC5['um'] dm = BC5['dm'] sm = BC5['sm'] cm = BC5['cm'] bm = BC5['bm'] tm = BC5['tm'] self.BC5 = self._get_BC(g, up, um, dp, dm, sp, sm, cp, cm, bp, bm, tp, tm) def evolve(self, Q2): if Q2 not in self.storage: if self.mb2 < Q2: self.storage[Q2] = self.dglap.evolve(self.BC5, self.mb2, Q2, 5) elif self.mc2 <= Q2 and Q2 <= self.mb2: self.storage[Q2] = self.dglap.evolve(self.BC4, self.mc2, Q2, 4) elif Q2 < self.mc2: self.storage[Q2] = self.dglap.evolve(self.BC3, self.Q20, Q2, 3) def get_xF(self, x, Q2, flav, evolve=True): if evolve: self.evolve(Q2) #return x*self.mellin.invert(x,self.storage[Q2][flav]) if self.shape == 'nderiv': return x * self.mellin.invert(x, self.storage[Q2][flav]) if self.shape == 'deriv': return x * self.mellin.invert_deriv(x, self.storage[Q2][flav]) def get_xF0(self, x, flav): if flav == 'um': mom = self.moms0['um'] elif flav == 'dm': mom = self.moms0['dm'] elif flav == 'sm': mom = self.moms0['sm'] #return x*conf['mellin'].invert(x,mom) if self.shape == 'nderiv': return x * conf['mellin'].invert(x, mom) if self.shape == 'deriv': return x * conf['mellin'].invert_deriv(x, mom) def get_C(self, x, Q2): self.evolve(Q2) #return np.array([self.mellin.invert(x,self.storage[Q2][_]) for _ in self.ford]) if self.shape == 'nderiv': return np.array([ self.mellin.invert(x, self.storage[Q2][_]) for _ in self.ford ]) if self.shape == 'deriv': return np.array([ self.mellin.invert_deriv(x, self.storage[Q2][_]) for _ in self.ford ]) def get_mom(self, Q2): #used for calculating the tensor charge for lattice data mom_arr = [] mom_arr.append(0.) for i in [1, 2, 3, 4, 5, 6]: #mom_arr.append(quad(lambda x: self.get_C(x,Q2)[i], 0., 1.)[0]) h1 = np.vectorize(lambda x: self.get_C(x, Q2)[i]) mom_arr.append(fixed_quad(h1, 0, 1, n=25)[0]) return np.array(mom_arr)
class FF(CORE): def __init__(self,spl,hadron,shape='nderiv'): self.hadron=hadron self.shape=shape self.Q20=conf['Q20'] self.mc2=conf['aux'].mc2 self.mb2=conf['aux'].mb2 self.mellin=conf['mellin'] self.kernel=KERNELS(self.mellin,spl) self.dglap=DGLAP(self.mellin,conf['alphaS'],self.kernel,'truncated','LO') self.set_default_params() self.setup() self.ford=['g','u','ub','d','db','s','sb','c','cb','b','bb'] def set_default_params(self): #--f(x) = norm * x**a1 * (1-x)**b1 * (1+c1*x+d1*x**2) * (1+ N2 * x**a2 * (1-x)**b2 * (1+c2*x+d2*x**2)) params={} params['g1'] = np.array([0,0,0,0,0,0,0,0,0,0]) params['u1'] = np.array([0.2,2.5,2.5,0,0,10.0,0,0,0,0]) params['d1'] = np.array([-0.4,0.5,3.4,0,0,10.0,0,0,0,0]) params['s1'] = np.array([0,0,0,0,0,0,0,0,0,0]) params['c1'] = np.array([0,0,0,0,0,0,0,0,0,0]) params['b1'] = np.array([0,0,0,0,0,0,0,0,0,0]) params['ub1'] = np.array([0,0,0,0,0,0,0,0,0,0]) params['db1'] = np.array([0,0,0,0,0,0,0,0,0,0]) params['sb1'] = np.array([0,0,0,0,0,0,0,0,0,0]) params['cb1'] = np.array([0,0,0,0,0,0,0,0,0,0]) params['bb1'] = np.array([0,0,0,0,0,0,0,0,0,0]) self.params=params #--widths self._widths1_fav = 0.3 self._widths1_ufav = 0.3 self._widths2_fav = 0 self._widths2_ufav = 0 # internal self.widths1 = np.ones(11) self.widths2 = np.ones(11) def set_sumrules(self): pass def set_moms(self): moms={} moms['g'] =self.get_moments('g1') moms['u1'] =self.get_moments('u1') moms['d1'] =self.get_moments('d1') moms['s1'] =self.get_moments('s1') moms['c1'] =self.get_moments('c1') moms['b1'] =self.get_moments('b1') moms['ub1']=self.get_moments('ub1') moms['db1']=self.get_moments('db1') moms['sb1']=self.get_moments('sb1') moms['cb1']=self.get_moments('cb1') moms['bb1']=self.get_moments('bb1') moms['up']=moms['u1']+moms['ub1'] moms['dp']=moms['d1']+moms['db1'] moms['sp']=moms['s1']+moms['sb1'] moms['cp']=moms['c1']+moms['cb1'] moms['bp']=moms['b1']+moms['bb1'] moms['um']=moms['u1']-moms['ub1'] moms['dm']=moms['d1']-moms['db1'] moms['sm']=moms['s1']-moms['sb1'] moms['cm']=moms['c1']-moms['cb1'] moms['bm']=moms['b1']-moms['bb1'] self.moms0=moms self.get_BC(moms) def set_widths(self): if self.hadron=='pi': i1,i2=1,4 elif self.hadron=='k': i1,i2=1,6 elif self.hadron=='h': i1,i2=1,4 for i in range(1, 11): if i==i1 or i==i2: self.widths1[i] = self._widths1_fav else: self.widths1[i] = self._widths1_ufav if i==i1 or i==i2: self.widths2[i] = self._widths2_fav else: self.widths2[i] = self._widths2_ufav def setup(self): #self.set_sumrules() self.set_moms() self.set_widths() #--store moments of a given Q2 that has been already calculated self.storage={} def beta(self,a,b): return gamma(a)*gamma(b)/gamma(a+b) def get_moments(self,flav,N=None): """ if N==None: then parametrization is to be use to compute moments along mellin contour else the Nth moment is returned """ if N==None: N=self.mellin.N M1,a1,b1,c1,d1,M2,a2,b2,c2,d2=self.params[flav] n1 = self.beta(a1+2,b1+1) + c1*self.beta(a1+3,b1+1) + d1*self.beta(a1+4,b1+1) n2 = M2 * (self.beta(a1+a2+2,b1+b2+1) + d1*d2*self.beta(a1+a2+6,b1+b2+1)) n3 = M2 * (c1+c2)*self.beta(a1+a2+3,b1+b2+1) n4 = M2 * (c1*d2+c2*d1)*self.beta(a1+a2+5,b1+b2+1) n5 = M2 * (c1*c2+d1+d2)*self.beta(a1+a2+4,b1+b2+1) norm=n1+n2+n3+n4+n5 if self.shape=='nderiv': m1 = self.beta(a1+N,b1+1) + c1*self.beta(a1+N+1,b1+1) + d1*self.beta(a1+N+2,b1+1) m2 = M2 * (self.beta(a1+a2+N,b1+b2+1) + d1*d2*self.beta(a1+a2+N+4,b1+b2+1)) m3 = M2 * (c1+c2)*self.beta(a1+a2+N+1,b1+b2+1) m4 = M2 * (c1*d2+c2*d1)*self.beta(a1+a2+N+3,b1+b2+1) m5 = M2 * (c1*c2+d1+d2)*self.beta(a1+a2+N+2,b1+b2+1) mom=m1+m2+m3+m4+m5 return M1*mom/norm elif self.shape=='deriv': m1 = self.beta(a1+(N-1),b1+1) + c1*self.beta(a1+(N-1)+1,b1+1) + d1*self.beta(a1+(N-1)+2,b1+1) m2 = M2 * (self.beta(a1+a2+(N-1),b1+b2+1) + d1*d2*self.beta(a1+a2+(N-1)+4,b1+b2+1)) m3 = M2 * (c1+c2)*self.beta(a1+a2+(N-1)+1,b1+b2+1) m4 = M2 * (c1*d2+c2*d1)*self.beta(a1+a2+(N-1)+3,b1+b2+1) m5 = M2 * (c1*c2+d1+d2)*self.beta(a1+a2+(N-1)+2,b1+b2+1) mom=(1-N)*(m1+m2+m3+m4+m5) return M1*mom/norm def _get_BC(self,g,up,um,dp,dm,sp,sm,cp,cm,bp,bm,tp,tm): N=self.mellin.N # flav composition vm,vp={},{} vm[35]= bm + cm + dm + sm - 5.0*tm + um vm[24]= -4*bm + cm + dm + sm + um vm[15]= -3*cm + dm + sm + um vm[8] = dm - 2.0*sp + 2.0*(-sm + sp) + um vm[3] = -dm + um vm[0] = np.zeros(N.size,dtype=complex) vp[0] = np.zeros(N.size,dtype=complex) vp[3] = -dp + up vp[8] = dp - 2.0*sp + up vp[15]= -3.0*cp + dp + sp + up vp[24]= -4.0*bp + cp + dp + sp + up vp[35]= bp + cp + dp + sp - 5.0*tp + up qs = bp + cp + dp + sp + tp + up qv = bm + cm + dm + sm + tm + um q = np.zeros((2,N.size),dtype=complex) q[0]=np.copy(qs) q[1]=np.copy(g) BC={} BC['vm']=vm BC['vp']=vp BC['qv']=qv BC['q'] =q return BC def get_state(self): return (self.widths1,self.widths2,self.BC3,self.BC4,self.BC5) def set_state(self,state): self.widths1,self.widths2,self.BC3, self.BC4, self.BC5 = state[:] self.storage = {} def get_BC(self,moms): N=self.mellin.N zero=np.zeros(N.size,dtype=complex) ###################################### # BC3 g = moms['g'] up = moms['up'] dp = moms['dp'] sp = moms['sp'] cp = zero bp = zero um = moms['um'] dm = moms['dm'] sm = moms['sm'] cm = zero bm = zero self.BC3=self._get_BC(g,up,um,dp,dm,sp,sm,cp,cm,bp,bm,zero,zero) ###################################### # BC for Nf=4 BC4=self.dglap.evolve(self.BC3,self.Q20,self.mc2,3) g =BC4['g'] up=BC4['up'] dp=BC4['dp'] sp=BC4['sp'] cp=moms['cp'] bp=zero um=BC4['um'] dm=BC4['dm'] sm=BC4['sm'] cm=moms['cm'] bm=zero self.BC4=self._get_BC(g,up,um,dp,dm,sp,sm,cp,cm,bp,bm,zero,zero) ###################################### # BC for Nf=5 BC5=self.dglap.evolve(self.BC4,self.mc2,self.mb2,4) g =BC5['g'] up=BC5['up'] dp=BC5['dp'] sp=BC5['sp'] cp=BC5['cp'] bp=moms['bp'] um=BC5['um'] dm=BC5['dm'] sm=BC5['sm'] cm=BC5['cm'] bm=moms['bm'] self.BC5=self._get_BC(g,up,um,dp,dm,sp,sm,cp,cm,bp,bm,zero,zero) def evolve(self,Q2): if Q2 not in self.storage: if self.mb2<Q2: self.storage[Q2]=self.dglap.evolve(self.BC5,self.mb2,Q2,5) elif self.mc2<=Q2 and Q2<=self.mb2: self.storage[Q2]=self.dglap.evolve(self.BC4,self.mc2,Q2,4) elif Q2<self.mc2: self.storage[Q2]=self.dglap.evolve(self.BC3,self.Q20,Q2,3) def get_xF(self,x,Q2,flav,evolve=True): if evolve: self.evolve(Q2) return x*self.mellin.invert(x,self.storage[Q2][flav]) def get_xF0(self,x,flav): if flav=='um': mom=self.moms0['um'] elif flav=='dm': mom=self.moms0['dm'] elif flav=='sm': mom=self.moms0['sm'] return x*conf['mellin'].invert(x,mom) def get_C(self,x, Q2): self.evolve(Q2) return np.array([self.mellin.invert(x,self.storage[Q2][_]) for _ in self.ford])
class PDF(CORE): def __init__(self, spl): self.Q20 = conf['Q20'] self.mc2 = conf['aux'].mc2 self.mb2 = conf['aux'].mb2 self.mellin = conf['mellin'] self.kernel = KERNELS(self.mellin, spl) self.dglap = DGLAP(self.mellin, conf['alphaS'], self.kernel, 'truncated', 'LO') self.set_params() self.setup() self.ford = [ 'g', 'u', 'ub', 'd', 'db', 's', 'sb', 'c', 'cb', 'b', 'bb' ] def set_params(self): #--f(x) = norm * x**a * (1-x)**b * (1+c*x**0.5+d*x) params = {} # first shapes params['g1'] = np.array([1, -0.5, 3, 0, 0]) params['uv1'] = np.array([1, 0.5, 3, 0, 0]) params['dv1'] = np.array([1, 0.5, 4, 0, 0]) params['sea1'] = np.array([1, -1.19, 4, 0, 0]) params['sea2'] = np.array([1, -1.19, 4, 0, 0]) params['db1'] = np.array([1, -0.5, 6, 0, 0]) params['ub1'] = np.array([1, -0.5, 6, 0, 0]) params['s1'] = np.array([0.02117505, -0.7834729, 5.94912366, 0., 0.]) params['sb1'] = np.array([0.03185304, -0.4761831, 10., 0., 0.]) self.params = params #--widthds self._widths1_uv = 0.3 self._widths1_dv = 0.3 self._widths1_sea = 0.3 self._widths2_uv = 0 self._widths2_dv = 0 self._widths2_sea = 0 # internal self.widths1 = np.ones(11) self.widths2 = np.ones(11) def set_sumrules(self): #--valence self.params['uv1'][0] = 1 self.params['uv1'][0] = 2 / self.get_moments('uv1', 1) self.params['dv1'][0] = 1 self.params['dv1'][0] = 1 / self.get_moments('dv1', 1) #--strange self.params['s1'][0] = 1 self.params['s1'][0] = self.get_moments('sb1', 1) / self.get_moments( 's1', 1) #--msr sea1 = self.get_moments('sea1', 2) sea2 = self.get_moments('sea2', 2) up = self.get_moments('uv1', 2) + 2 * (sea1 + self.get_moments('ub1', 2)) dp = self.get_moments('dv1', 2) + 2 * (sea1 + self.get_moments('db1', 2)) sp = (sea2 + self.get_moments('s1', 2)) + (sea2 + self.get_moments('sb1', 2)) self.params['g1'][0] = 1 self.params['g1'][0] = (1 - up - dp - sp) / self.get_moments('g1', 2) g = self.get_moments('g1', 2) msr = g + up + dp + sp #--share self.sr = {} self.sr['msr'] = msr self.sr['uv(1)'] = self.get_moments('uv1', 1) self.sr['dv(1)'] = self.get_moments('dv1', 1) self.sr['s-sb(1)'] = self.get_moments('s1', 1) - self.get_moments( 'sb1', 1) self.sr['s-sb(2)'] = self.get_moments('s1', 2) - self.get_moments( 'sb1', 2) self.sr['db-ub(1)'] = self.get_moments('db1', 1) - self.get_moments( 'ub1', 1) self.sr['db-ub(2)'] = self.get_moments('db1', 2) - self.get_moments( 'ub1', 2) #for _ in sorted(self.sr): print _, self.sr[_] def set_moms(self): sea1 = self.get_moments('sea1') sea2 = self.get_moments('sea2') moms = {} moms['g'] = self.get_moments('g1') moms['up'] = self.get_moments('uv1') + 2 * (sea1 + self.get_moments('ub1')) moms['dp'] = self.get_moments('dv1') + 2 * (sea1 + self.get_moments('db1')) moms['sp'] = 2 * sea2 + self.get_moments('s1') + self.get_moments( 'sb1') moms['um'] = self.get_moments('uv1') moms['dm'] = self.get_moments('dv1') moms['sm'] = self.get_moments('s1') - self.get_moments('sb1') self.moms0 = moms self.get_BC(moms) def set_widths(self): for i in range(11): if i == 1: self.widths1[i] = self._widths1_uv elif i == 3: self.widths1[i] = self._widths1_dv else: self.widths1[i] = self._widths1_sea for i in range(11): if i == 1: self.widths2[i] = self._widths2_uv elif i == 3: self.widths2[i] = self._widths2_dv else: self.widths2[i] = self._widths2_sea def setup(self): self.set_sumrules() self.set_moms() self.set_widths() #--store moments of a given Q2 that has been already calculated self.storage = {} def beta(self, a, b): return gamma(a) * gamma(b) / gamma(a + b) def get_moments(self, flav, N=None): """ if N==None: then parametrization is to be use to compute moments along mellin contour else the Nth moment is returned """ if N == None: N = self.mellin.N M, a, b, c, d = self.params[flav] norm = self.beta(2 + a, b + 1) + c * self.beta( 2 + a + 0.5, b + 1) + d * self.beta(2 + a + 1.0, b + 1) mom = self.beta(N + a, b + 1) + c * self.beta( N + a + 0.5, b + 1) + d * self.beta(N + a + 1.0, b + 1) return M * mom / norm def _get_BC(self, g, up, um, dp, dm, sp, sm, cp, cm, bp, bm, tp, tm): N = self.mellin.N # flav composition vm, vp = {}, {} vm[35] = bm + cm + dm + sm - 5 * tm + um vm[24] = -4 * bm + cm + dm + sm + um vm[15] = -3 * cm + dm + sm + um vm[8] = dm - 2 * sp + 2 * (-sm + sp) + um vm[3] = -dm + um vm[0] = np.zeros(N.size, dtype=complex) vp[0] = np.zeros(N.size, dtype=complex) vp[3] = -dp + up vp[8] = dp - 2 * sp + up vp[15] = -3 * cp + dp + sp + up vp[24] = -4 * bp + cp + dp + sp + up vp[35] = bp + cp + dp + sp - 5 * tp + up qs = bp + cp + dp + sp + tp + up qv = bm + cm + dm + sm + tm + um q = np.zeros((2, N.size), dtype=complex) q[0] = np.copy(qs) q[1] = np.copy(g) BC = {} BC['vm'] = vm BC['vp'] = vp BC['qv'] = qv BC['q'] = q return BC def get_state(self): return (self.widths1, self.widths2, self.BC3, self.BC4, self.BC5) def set_state(self, state): self.widths1, self.widths2, self.BC3, self.BC4, self.BC5 = state[:] self.storage = {} def get_BC(self, moms): N = self.mellin.N zero = np.zeros(N.size, dtype=complex) ############################################### # BC for Nf=3 g = moms['g'] up = moms['up'] um = moms['um'] dp = moms['dp'] dm = moms['dm'] sp = moms['sp'] sm = moms['sm'] cp = zero cm = zero bp = zero bm = zero self.BC3 = self._get_BC(g, up, um, dp, dm, sp, sm, zero, zero, zero, zero, zero, zero) ############################################### # BC for Nf=4 BC4 = self.dglap.evolve(self.BC3, self.Q20, self.mc2, 3) g = BC4['g'] up = BC4['up'] dp = BC4['dp'] sp = BC4['sp'] cp = BC4['cp'] bp = BC4['bp'] tp = BC4['tp'] um = BC4['um'] dm = BC4['dm'] sm = BC4['sm'] cm = BC4['cm'] bm = BC4['bm'] tm = BC4['tm'] self.BC4 = self._get_BC(g, up, um, dp, dm, sp, sm, cp, cm, bp, bm, tp, tm) ############################################### # BC for Nf=5 BC5 = self.dglap.evolve(self.BC4, self.mc2, self.mb2, 4) g = BC5['g'] up = BC5['up'] dp = BC5['dp'] sp = BC5['sp'] cp = BC5['cp'] bp = BC5['bp'] tp = BC5['tp'] um = BC5['um'] dm = BC5['dm'] sm = BC5['sm'] cm = BC5['cm'] bm = BC5['bm'] tm = BC5['tm'] self.BC5 = self._get_BC(g, up, um, dp, dm, sp, sm, cp, cm, bp, bm, tp, tm) def evolve(self, Q2): if Q2 not in self.storage: if self.mb2 < Q2: self.storage[Q2] = self.dglap.evolve(self.BC5, self.mb2, Q2, 5) elif self.mc2 <= Q2 and Q2 <= self.mb2: self.storage[Q2] = self.dglap.evolve(self.BC4, self.mc2, Q2, 4) elif Q2 < self.mc2: self.storage[Q2] = self.dglap.evolve(self.BC3, self.Q20, Q2, 3) def get_xF(self, x, Q2, flav, evolve=True): if evolve: self.evolve(Q2) return x * self.mellin.invert(x, self.storage[Q2][flav]) def get_xF0(self, x, flav): if flav == 'um': mom = self.moms0['um'] elif flav == 'dm': mom = self.moms0['dm'] elif flav == 'sm': mom = self.moms0['sm'] return x * conf['mellin'].invert(x, mom) def get_C(self, x, Q2): self.evolve(Q2) return np.array( [self.mellin.invert(x, self.storage[Q2][_]) for _ in self.ford]) def get_dC(self, x, Q2): """ print we need to think how to do this here """ return 0 #self.get_dcollinear(x,Q2)