Esempio n. 1
0
def run():
    def f2(x,y):
        return numx.sin(x) / x
    sys2 = integrate.gsl_function(f2, None)
    
    def f1(x,y):
        return 1 / x        
    sys1 = integrate.gsl_function(f1, None)
    
    def f3(x,y):
        return 1 / -x
    
    sys3 = integrate.gsl_function(f3, None)

    w = integrate.workspace(1000000)
    cyclew = integrate.workspace(1000000)
    
    table1 = integrate.qawo_table(1, 100, integrate.SINE, 100)
    table2 = integrate.qawo_table(-1, 100, integrate.SINE, 100)

    # Borders and singualrity for gagp
    pts = numx.array((-numx.pi, 0, numx.pi))
    
    flag, result1, error = integrate.qagp(sys2, pts, 1e-8, 1e-8, 100000, w)
    flag, result2, error = integrate.qawf(sys1, numx.pi, 1e-8,  100, w,
                                          cyclew, table1)
    flag, result3, error = integrate.qawf(sys3, numx.pi, 1e-8,  100, w,
                                          cyclew, table2)
    
    print "Result of integration is :", result1 + result2 + result3
Esempio n. 2
0
def run():
    def f2(x, y):
        return numx.sin(x) / x

    sys2 = integrate.gsl_function(f2, None)

    def f1(x, y):
        return 1 / x

    sys1 = integrate.gsl_function(f1, None)

    def f3(x, y):
        return 1 / -x

    sys3 = integrate.gsl_function(f3, None)

    w = integrate.workspace(1000000)
    cyclew = integrate.workspace(1000000)

    table1 = integrate.qawo_table(1, 100, integrate.SINE, 100)
    table2 = integrate.qawo_table(-1, 100, integrate.SINE, 100)

    # Borders and singualrity for gagp
    pts = numx.array((-numx.pi, 0, numx.pi))

    flag, result1, error = integrate.qagp(sys2, pts, 1e-8, 1e-8, 100000, w)
    flag, result2, error = integrate.qawf(sys1, numx.pi, 1e-8, 100, w, cyclew,
                                          table1)
    flag, result3, error = integrate.qawf(sys3, numx.pi, 1e-8, 100, w, cyclew,
                                          table2)

    print "Result of integration is :", result1 + result2 + result3
Esempio n. 3
0
    def test_qawf(self):
        def f2(x, y):
            return Numeric.sin(x) / x

        sys2 = integrate.gsl_function(f2, None)

        def f1(x, y):
            return 1 / x

        sys1 = integrate.gsl_function(f1, None)

        def f3(x, y):
            return 1 / -x

        sys3 = integrate.gsl_function(f3, None)

        pts = Numeric.array((-Numeric.pi, 0, Numeric.pi))
        flag, result1, error = integrate.qagp(sys2, pts, 1e-8, 1e-8, 100000,
                                              self.w)
        table1 = integrate.qawo_table(1, 100, integrate.SINE, 100)
        cyclew = integrate.workspace(1000000)
        flag, result2, error = integrate.qawf(sys1, Numeric.pi, 1e-8, 100,
                                              self.w, cyclew, table1)
        table2 = integrate.qawo_table(-1, 100, integrate.SINE, 100)
        flag, result3, error = integrate.qawf(sys3, Numeric.pi, 1e-8, 100,
                                              self.w, cyclew, table2)
        assert (Numeric.absolute(result1 + result2 + result3 - Numeric.pi) <
                1e-8)
Esempio n. 4
0
 def test_qawf(self):
     def f2(x,y):
         return Numeric.sin(x) / x
     sys2 = integrate.gsl_function(f2, None)
     def f1(x,y):
         return 1 / x        
     sys1 = integrate.gsl_function(f1, None)
     def f3(x,y):
         return 1 / -x        
     sys3 = integrate.gsl_function(f3, None)
     
     pts = Numeric.array((-Numeric.pi, 0, Numeric.pi))
     flag, result1, error = integrate.qagp(sys2, pts, 1e-8, 1e-8, 100000, self.w)
     table1 = integrate.qawo_table(1, 100, integrate.SINE, 100)        
     cyclew = integrate.workspace(1000000)
     flag, result2, error = integrate.qawf(sys1, Numeric.pi, 1e-8,  100, self.w, cyclew, table1)
     table2 = integrate.qawo_table(-1, 100, integrate.SINE, 100)        
     flag, result3, error = integrate.qawf(sys3, Numeric.pi, 1e-8,  100, self.w, cyclew, table2)
     assert(Numeric.absolute(result1+result2+result3 - Numeric.pi) < 1e-8)
Esempio n. 5
0
 def getage(self,z): 
  """Look-back time as a function of redhshift.  Returns time in tunit.  
     Hogg paper Equation 30.
  """
  def agefunc(z2,y):
   return 1./ (self.epeebles(z2)*(1.+z2))
  
  #gsl baggage
  gsl_agefunc=integ.gsl_function(agefunc,None) #extra pygsl baggage
  w=integ.workspace(1000000)

  try: #check if z is list or array
   output=[]
   for zz in z:
    flag,result,error=integ.qagiu(gsl_agefunc,zz,1e-8,1e-8,100000,w) 
    output.append(self.thubble()*result)
   output=numpy.array(output)
   return output
  except TypeError: #z is single value
   flag,result,error=integ.qagiu(gsl_agefunc,z,1e-8,1e-8,100000,w) 
   output=self.thubble()*result
  return output
Esempio n. 6
0
 def setUp(self):
     self.w = integrate.workspace(1000000)
Esempio n. 7
0
def main():

    parser = argparse.ArgumentParser(description='Simulation of selected and neutral site frequency spectra using the Poisson Random Field Model (PRF)')
    parser.add_argument('-n', '--nsam', type=int, required=True, dest='sample', help='The sample size')
    parser.add_argument('-t', '--theta', type=float, required=True, dest='theta', help='The scaled mutation parameter per site')
    parser.add_argument('-g', '--gamma', type=float, required=True, dest='gamma', help='The scaled selection coefficient (Ns). Can be positive or negative')
    parser.add_argument('-N', '--Nsites', required=True, type=int, dest='length_S', help = 'Size of region for neutral sites in base pairs to simulate using the PRF [default: 500] ')
    parser.add_argument('-S', '--Ssites', required=True, type=int, dest='length_N', help = 'Size of region for selected sites in base pairs to simulate using the PRF [default: 500] ')
    parser.add_argument('-o', '--out', required=True, dest='outfile', help = 'Output file for simulated Neutral and Selected sites site frequency spectra')
    parser.add_argument('-s', '--sfs', default='folded', required=False, dest='fold', help = 'Specify folded or unfolded [ default: folded]')
    args = parser.parse_args()

    n = args.sample
    
    Ls_N = args.length_N
    theta_ls_N = args.theta * Ls_N
    
    Ls_S = args.length_S
    theta_ls_S = args.theta * Ls_S # specified theta per site at input, so multiply by length

    gamma = args.gamma # gamma in Kai's program is twice that in the Bustamante paper so multiply by a half


    if args.fold == 'folded':
        fold = True
    elif args.fold == 'unfolded':
        fold = False
    else:
        print('Invalid option for -s, it should be folded or unfolded')
        sys.exit(1)
    
    with open(args.outfile, 'w') as outfile:
    
        nl = 1 # consider adding option to have multiple replicate of varying size output
        sfs = []
        workspace = integrate.workspace(1000000)
        if fold:
            print('S', file=outfile)
            print(nl, file=outfile)
            for i in xrange(1, (n + 2) / 2):
                if gamma == 0: # still print "Selected" sites in output when gamma is zero
                    if i < (n - i):
                        nci = n_choose_i(n, i)
                        neutral_integrand_eq2_func = integrate.gsl_function(neutral_integrand_eq2, [nci, n, i])
                        F_i_gamma = integrate.qag(neutral_integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                        
                        nci = n_choose_i(n, n - i)
                        neutral_integrand_eq2_func = integrate.gsl_function(neutral_integrand_eq2, [nci, n, n - i])
                        F_n_minus_i_gamma = integrate.qag(neutral_integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
    
                        G_i_gamma = F_i_gamma + F_n_minus_i_gamma # equation 6 condition i < n - i
                        
                        xN = get_sfs(G_i_gamma, theta_ls_N)
                        print(i, G_i_gamma*theta_ls_N)
                        sfs.append(str(xN))
    
                    elif i == n / 2:
                        nci = n_choose_i(n, n / 2)
                        neutral_integrand_eq2_func = integrate.gsl_function(neutral_integrand_eq2, [nci, n, n / 2])
                        F_n_over_two_gamma = integrate.qag(neutral_integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                        xN = get_sfs(F_n_over_two_gamma, theta_ls_N)
                        print(i, F_n_over_two_gamma * theta_ls_N)
                        sfs.append(str(xN))
                        
                elif gamma < 0:
                    if i < (n - i):
                        nci = n_choose_i(n, i)
                        integrand_eq2_func = integrate.gsl_function(integrand_eq2_neg, [gamma, nci, n, i])
                        F_i_gamma = integrate.qag(integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                        
                        
                        nci = n_choose_i(n, n - i)
                        integrand_eq2_func = integrate.gsl_function(integrand_eq2_neg, [gamma, nci, n, n - i])
                        F_n_minus_i_gamma = integrate.qag(integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]

                        G_i_gamma = F_i_gamma + F_n_minus_i_gamma # equation 6 condition i < n - i                                                                               
                        
                        #print(G_i_gamma, F_i_gamma, F_n_minus_i_gamma)
                        xS = get_sfs(G_i_gamma, theta_ls_S)
                        print(i, G_i_gamma * theta_ls_S)
                        sfs.append(str(xS))
                    
                    elif i == n / 2: # floor division in python 2
                        nci = n_choose_i(n, n / 2)
                        integrand_eq2_func = integrate.gsl_function(integrand_eq2_neg, [gamma, nci, n, n / 2])
                        F_n_over_two_gamma = integrate.qag(integrand_eq2_func, 0, 1, 1e-10, 1e-10, 1000, integrate.GAUSS61, workspace)[1]
                        xS = get_sfs(F_n_over_two_gamma , theta_ls_S)
                        #print(F_n_over_two_gamma)
                        print(i, F_n_over_two_gamma * theta_ls_S)
                        sfs.append(str(xS))
                    
    
                else:
                    if i < (n - i):
                        nci = n_choose_i(n, i)
                        integrand_eq2_func = integrate.gsl_function(integrand_eq2, [gamma, nci, n, i])
                        F_i_gamma = integrate.qag(integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
    
                        nci = n_choose_i(n, n - i)
                        integrand_eq2_func = integrate.gsl_function(integrand_eq2, [gamma, nci, n, n - i])
                        F_n_minus_i_gamma = integrate.qag(integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
    
                        G_i_gamma = F_i_gamma + F_n_minus_i_gamma # equation 6 condition i < n - i
                        xS = get_sfs(G_i_gamma, theta_ls_S)
                        print(i, G_i_gamma * theta_ls_S)
                        sfs.append(str(xS))
    
                    elif i == n / 2: # floor division in python 2
                        nci = n_choose_i(n, n / 2)
                        integrand_eq2_func = integrate.gsl_function(integrand_eq2, [gamma, nci, n, n / 2])
                        F_n_over_two_gamma = integrate.qag(integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                        xS = get_sfs(F_n_over_two_gamma , theta_ls_S)
                        print(i, F_n_over_two_gamma * theta_ls_S)
                        sfs.append(str(xS))
    
            sfs_string = ', '.join(sfs)
            print(n, Ls_S, sfs_string, sep=', ', file=outfile)
            del sfs[:]
    
    
            # Neutral sites
            print('N', file=outfile)
            print(nl, file=outfile)
            for i in xrange(1, (n + 2) / 2):
                if i < (n - i):
                    nci = n_choose_i(n, i)
                    neutral_integrand_eq2_func = integrate.gsl_function(neutral_integrand_eq2, [nci, n, i])
                    F_i_gamma = integrate.qag(neutral_integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
    
                    nci = n_choose_i(n, n - i)
                    neutral_integrand_eq2_func = integrate.gsl_function(neutral_integrand_eq2, [nci, n, n - i])
                    F_n_minus_i_gamma = integrate.qag(neutral_integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
    
                    G_i_gamma = F_i_gamma + F_n_minus_i_gamma # equation 6 condition i < n - i
                    xN = get_sfs(G_i_gamma, theta_ls_N)
                    #print(i, G_i_gamma * theta_ls_N)
                    sfs.append(str(xN))
    
                elif i == n / 2:
                    nci = n_choose_i(n, n / 2)
                    neutral_integrand_eq2_func = integrate.gsl_function(neutral_integrand_eq2, [nci, n, n / 2])
                    F_n_over_two_gamma = integrate.qag(neutral_integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                    xN = get_sfs(F_n_over_two_gamma, theta_ls_N)
                    #print(i, F_n_over_two_gamma * theta_ls_N)
                    sfs.append(str(xN))
    
            sfs_string = ', '.join(sfs)
            print(n, Ls_N, sfs_string, sep=', ', file=outfile)
            del sfs[:]
    
        else: # produce unfolded sfs
            print('S', file=outfile)
            print(nl, file=outfile)
            for i in xrange(1, n):
                if gamma == 0:
                    nci = n_choose_i(n , i)
                    neutral_integrand_eq2_func = integrate.gsl_function(neutral_integrand_eq2, [nci, n, i])
                    eq2_eval_neut = integrate.qag(neutral_integrand_eq2_func, 0, 1,  1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                    xN = get_sfs(eq2_eval_neut, theta_ls_N)
                    # print(i, xN)
                    sfs.append(str(xN))
                    
                elif gamma < 0:
                    nci = n_choose_i(n, i)
                    integrand_eq2_func = integrate.gsl_function(integrand_eq2_neg, [gamma, nci, n, i])
                    eq2_eval_sel = integrate.qag(integrand_eq2_func, 0, 1,  1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                    xS = get_sfs(eq2_eval_sel, theta_ls_S)
                    # print(i, eq2_eval_sel)                                                                                                                                     
                    sfs.append(str(xS))
                    
                else:
                    nci = n_choose_i(n, i)
                    integrand_eq2_func = integrate.gsl_function(integrand_eq2, [gamma, nci, n, i])
                    eq2_eval_sel = integrate.qag(integrand_eq2_func, 0, 1,  1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                    xS = get_sfs(eq2_eval_sel, theta_ls_S)
                    # print(i, eq2_eval_sel)
                    sfs.append(str(xS))
    
    
            sfs_string = ', '.join(sfs)
            print(n, Ls_S, sfs_string, sep=', ', file=outfile)
            del sfs[:]
    
            print('N', file=outfile)
            print(nl, file=outfile)
            for i in xrange(1, n):
                nci = n_choose_i(n , i)
                neutral_integrand_eq2_func = integrate.gsl_function(neutral_integrand_eq2, [nci, n, i])
                eq2_eval_neut = integrate.qag(neutral_integrand_eq2_func, 0, 1, 1e-8, 1e-8, 1000, integrate.GAUSS61, workspace)[1]
                xN = get_sfs(eq2_eval_neut, theta_ls_N)
                # print(i, xN)
                sfs.append(str(xN))
    
            sfs_string = ', '.join(sfs)
            print(n, Ls_N, sfs_string, sep=', ', file=outfile)
            del sfs[:]
Esempio n. 8
0
from PMFpack import *
from numpy import *
from pylab import *
from pygsl import integrate
from scipy.integrate import quad, dblquad, Inf
from scipy.special import erf, erfinv

w1 = integrate.workspace(10000)
w2 = integrate.workspace(10000)

#fmean = 0.639756248702123
#sigma = 0.16674922174125
#pmf = PMF(fmean, sigma, 0, 0, 0, 2)
#pmf.set_fmean_gradient(-0.4178939524532, 0, 0)  # Last two are zero because the simulation is 1D
#pmf.set_sigma_gradient(-0.5095137299633, 0, 0)
#pmf.chi = 0.38430391476813  # Mean scalar dissipation rate (defined with the factor 2)

#fmean = 0.32734785270559791
#sigma = 0.036258388156940768 
#pmf = PMF(fmean, sigma, 0, 0, 0, 2)
#pmf.set_fmean_gradient(-0.40312611148071925, 0, 0)  # Last two are zero because the simulation is 1D
#pmf.set_sigma_gradient(-0.29357760186462173, 0, 0)
#pmf.chi = 0.36258388156940158  # Mean scalar dissipation rate (defined with the factor 2)

#fmean = 0.67265214729440204
#sigma = 0.036258388156940768
#pmf = PMF(fmean, sigma, 0, 0, 0, 2)
#pmf.set_fmean_gradient(-0.40312611148071925, 0, 0)  # Last two are zero because the simulation is 1D
#pmf.set_sigma_gradient(-0.51267462109681816, 0, 0)
#pmf.chi = 0.36258388156940158  # Mean scalar dissipation rate (defined with the factor 2)
Esempio n. 9
0
def GetSelfEnergyRPADummyMomFrequency(n, omega, kappa, L, asymptoteParams, nbrRTraining=40, orderInterpolate=3, nbrRTest=200, workspaceSize=100, maxBisections=100, epsilonQuad=1.0e-07,
                                      epsilonRelQuad=1.0e-04, useInterpolator=True, verbose=False, findEnergy=False):
    """n: vector of integers characterizing external momentum"""
    """omega: external frequency OR energy"""
    """kappa: hopping (eV)"""
    """L: vector of integers characterizing size of lattice"""
    """asymptoteParams: tensor of fit parameter characterizing asymptote of \delta \Pi at large frequency"""
    """nbrRTaining: number of points for training interpolator for integrand"""
    """nbrRTest: number of points to test integrand"""
    """workspaceSize: GSL integration workspace size"""
    """maxBisections: GSL integration number of subdivisions"""
    """epsilonQuad: absolute error for integration"""
    """epsilonRelQuad: relative error for integration"""
    """useInterpolator: use the interpolation routine or explicit evalaution of \delta \Pi"""
    """verbose: output integrand?"""
    """findEnergy: searching for energy? i.e. omega \to i\omega (Wick rotation)"""
    assert(len(n)==2)
    assert(len(L)==2)
    assert(len(asymptoteParams.shape)==2)
    assert(asymptoteParams.shape[0]==L[0])
    assert(asymptoteParams.shape[1]==L[1])
        
    prefactor = -1/(4*np.pi*L[0]*L[1])
    resultIntegration = np.zeros((int(L[0]),int(L[1]),4))
    work = integrate.workspace(workspaceSize) #create workspace for integration
    bareSigma = GetSelfEnergyBareDummyMom(n,kappa,L)
    result = 0.0
    for n1 in range(int(L[0])): # sum over spatial loop momentum \vec{q}
        for n2 in range(int(L[1])):
            # integrate over q_0 for each loop momentum \vec{q}
            nLoop = np.copy([n1,n2])
            print 'GetSelfEnergyRPADummyMomFrequency nLoop:',nLoop
            pPlusLoop = n+nLoop[:]
            pMinusLoop = n-nLoop[:]
            
            factorPlusLoop = ComputeStructureFactorHexagonalNN(pPlusLoop,L)
            factorMinusLoop = ComputeStructureFactorHexagonalNN(pMinusLoop,L)
            
            w = asymptoteParams[n1,n2] # get parameter which defines change of variables

            assert(w>0)
            rMax = 0.5*np.pi/w

            if useInterpolator:
                rIntegrandTrain = np.linspace(-rMax,rMax,num=nbrRTraining,endpoint=True)
                integrandTrain = np.zeros((nbrRTraining,2))
            
            if verbose:
                rIntegrandTest = np.linspace(-rMax,rMax,num=nbrRTest,endpoint=True)
                integrandData = np.zeros((nbrRTest,2))
                        
            if np.abs(factorPlusLoop) > 1.0e-10:

                if findEnergy:
                    numReal = lambda r: GetSigmaRPAIntegrandWeight(r,w)*((np.abs(factorPlusLoop)**2-omega**2+w*np.tan(r*w))*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).real
                                                                         + 2*omega*w*np.tan(r*w)*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).imag)
                    denom = lambda r: ((1j*omega+w*np.tan(r*w))**2+np.abs(factorPlusLoop)**2)*((-1j*omega+w*np.tan(r*w))**2+np.abs(factorPlusLoop)**2)
                    realIntegrand1 = lambda r: numReal(r)/denom(r)
                    numImag = lambda r: GetSigmaRPAIntegrandWeight(r,w)*((np.abs(factorPlusLoop)**2-omega**2+w*np.tan(r*w))*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).imag
                                                                         - 2*omega*w*np.tan(r*w)*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).real)
                    imagIntegrand1 = lambda r: numImag(r)/denom(r)
                else:
                    # \delta \Pi_{1,2}(q_0, \vec{q}) G_{(0);2,1}(p_0+q_0,\vec{p}+\vec{q})
                    realIntegrand1 = lambda r: GetSigmaRPAIntegrandWeight(r,w)*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).real/((omega+w*np.tan(r*w))**2 + (kappa*np.abs(factorPlusLoop))**2)
                    imagIntegrand1 = lambda r: GetSigmaRPAIntegrandWeight(r,w)*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).imag/((omega+w*np.tan(r*w))**2 + (kappa*np.abs(factorPlusLoop))**2)

                if useInterpolator:
                    for i in range(nbrRTraining):
                        integrandTrain[i,0] = realIntegrand1(rIntegrandTrain[i])
                        integrandTrain[i,1] = imagIntegrand1(rIntegrandTrain[i])
                
                    realIntegrand1Interp = InterpolationWrappers.MyUnivariateSpline(x=rIntegrandTrain,y=integrandTrain[:,0],name="realIntegrand1",order=orderInterpolate,boundsError=True,verbose=True)
                    imagIntegrand1Interp = InterpolationWrappers.MyUnivariateSpline(x=rIntegrandTrain,y=integrandTrain[:,1],name="imagIntegrand1",order=orderInterpolate,boundsError=True,verbose=True)

                    realIntFuc = integrate.gsl_function(MakeIntFunction(realIntegrand1Interp.EvaluateUnivariateInterpolationPoint), None) #set function to be integrated (real)
                    imagIntFuc = integrate.gsl_function(MakeIntFunction(imagIntegrand1Interp.EvaluateUnivariateInterpolationPoint), None) #set function to be integrated (imag)
                else:
                    realIntFuc = integrate.gsl_function(MakeIntFunction(realIntegrand1), None) #set function to be integrated (real)
                    imagIntFuc = integrate.gsl_function(MakeIntFunction(imagIntegrand1), None) #set function to be integrated (imag)

                flag, resultIntegration[n1,n2,0], error = integrate.qag(realIntFuc, -rMax, rMax, epsilonQuad, epsilonRelQuad, maxBisections, integrate.GAUSS61, work)
                flag, resultIntegration[n1,n2,1], error = integrate.qag(imagIntFuc, -rMax, rMax, epsilonQuad, epsilonRelQuad, maxBisections, integrate.GAUSS61, work)

                if verbose:
                    for i in range(nbrRTest):
                        if useInterpolator:
                            integrandData[i,0] = realIntegrand1Interp.EvaluateUnivariateInterpolationPoint(rIntegrandTest[i])
                            integrandData[i,1] = imagIntegrand1Interp.EvaluateUnivariateInterpolationPoint(rIntegrandTest[i])
                        else:
                            integrandData[i,0] = realIntegrand1(rIntegrandTest[i])
                            integrandData[i,1] = imagIntegrand1(rIntegrandTest[i])

                    Output1DGrid("Integrand1_kappa_%g_alpha_%g_P_%d_%d_Q_%d_%d_omega_%g_L_%d_nbrR_%d"%(kappa,alpha,n[0],n[1],nLoop[0],nLoop[1],omega,L[0],nbrRTest),
                                 rIntegrandTest,integrandData)
                
                result += -kappa*np.conj(factorPlusLoop)*(resultIntegration[n1,n2,0]+1j*resultIntegration[n1,n2,1])

                filename = "RPA_INTEGRAL1_P_%d_%d_Q_%d_%d_omega_%e"%(n[0],n[1],nLoop[0],nLoop[1],omega)
                checkExistingFile(filename)
                if verbose:
                    with open(filename, "w") as text_file:
                        if useInterpolator:
                            text_file.write("interpolator_result: %.16e %.16e\n"%(resultIntegration[n1,n2,0],resultIntegration[n1,n2,1]))
                        else:
                            text_file.write("exact_result: %.16e %.16e\n"%(resultIntegration[n1,n2,0],resultIntegration[n1,n2,1]))
                        text_file.close()
                                                                    
            if np.abs(factorMinusLoop) > 1.0e-10:

                if findEnergy:
                    numReal = lambda r: GetSigmaRPAIntegrandWeight(r,w)*((np.abs(factorMinusLoop)**2-omega**2+w*np.tan(r*w))*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).real
                                                                         - 2*omega*w*np.tan(r*w)*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).imag)
                    denom = lambda r: ((1j*omega-w*np.tan(r*w))**2+np.abs(factorMinusLoop)**2)*((-1j*omega+w*np.tan(r*w))**2-np.abs(factorMinusLoop)**2)
                    realIntegrand2 = lambda r: numReal(r)/denom(r)
                    numImag = lambda r: GetSigmaRPAIntegrandWeight(r,w)*((np.abs(factorMinusLoop)**2-omega**2+w*np.tan(r*w))*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).imag
                                                                         + 2*omega*w*np.tan(r*w)*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).real)
                    imagIntegrand2 = lambda r: numImag(r)/denom(r)
                else:
                    # \delta \Pi_{2,1}(q_0, \vec{q}) G_{(0);2,1}(p_0-q_0,\vec{p}+\vec{q})
                    realIntegrand2 = lambda r: GetSigmaRPAIntegrandWeight(r,w)*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).real/((omega-w*np.tan(r*w))**2 + (kappa*np.abs(factorMinusLoop))**2)
                    imagIntegrand2 = lambda r: -GetSigmaRPAIntegrandWeight(r,w)*GetDifferenceDummyBosonPropagator(nLoop,w*np.tan(r*w),kappa,alpha,L).imag/((omega-w*np.tan(r*w))**2 + (kappa*np.abs(factorMinusLoop))**2)

                if useInterpolator:
                    for i in range(nbrRTraining):
                        integrandTrain[i,0] = realIntegrand2(rIntegrandTrain[i])
                        integrandTrain[i,1] = imagIntegrand2(rIntegrandTrain[i])
                
                    realIntegrand2Interp = InterpolationWrappers.MyUnivariateSpline(x=rIntegrandTrain,y=integrandTrain[:,0],name="realIntegrand2",order=orderInterpolate,boundsError=True,verbose=True)
                    imagIntegrand2Interp = InterpolationWrappers.MyUnivariateSpline(x=rIntegrandTrain,y=integrandTrain[:,1],name="imagIntegrand2",order=orderInterpolate,boundsError=True,verbose=True)

                    realIntFuc = integrate.gsl_function(MakeIntFunction(realIntegrand2Interp.EvaluateUnivariateInterpolationPoint), None) #set function to be integrated (real)
                    imagIntFuc = integrate.gsl_function(MakeIntFunction(imagIntegrand2Interp.EvaluateUnivariateInterpolationPoint), None) #set function to be integrated (imag)
                else:
                    realIntFuc = integrate.gsl_function(MakeIntFunction(realIntegrand2), None) #set function to be integrated (real)
                    imagIntFuc = integrate.gsl_function(MakeIntFunction(imagIntegrand2), None) #set function to be integrated (imag)

                flag, resultIntegration[n1,n2,2], error = integrate.qag(realIntFuc, -rMax, rMax, epsilonQuad, epsilonRelQuad, maxBisections, integrate.GAUSS61, work)
                flag, resultIntegration[n1,n2,3], error = integrate.qag(imagIntFuc, -rMax, rMax, epsilonQuad, epsilonRelQuad, maxBisections, integrate.GAUSS61, work)

                if verbose:
                    for i in range(nbrRTest):
                        if useInterpolator:
                            integrandData[i,0] = realIntegrand2Interp.EvaluateUnivariateInterpolationPoint(rIntegrandTest[i])
                            integrandData[i,1] = imagIntegrand2Interp.EvaluateUnivariateInterpolationPoint(rIntegrandTest[i])
                        else:
                            integrandData[i,0] = realIntegrand2(rIntegrandTest[i])
                            integrandData[i,1] = imagIntegrand2(rIntegrandTest[i])

                    Output1DGrid("Integrand2_kappa_%g_alpha_%g_P_%d_%d_Q_%d_%d_omega_%g_L_%d_nbrR_%d"%(kappa,alpha,n[0],n[1],nLoop[0],nLoop[1],omega,L[0],nbrRTest),
                                 rIntegrandTest,integrandData)

                result += -kappa*np.conj(factorMinusLoop)*(resultIntegration[n1,n2,2]+1j*resultIntegration[n1,n2,3])

                filename = "RPA_INTEGRAL2_P_%d_%d_Q_%d_%d_omega_%e"%(n[0],n[1],nLoop[0],nLoop[1],omega)
                checkExistingFile(filename)
                if verbose:
                    with open(filename, "w") as text_file:
                        if useInterpolator:
                            text_file.write("interpolator_result: %.16e %.16e\n"%(resultIntegration[n1,n2,2],resultIntegration[n1,n2,3]))
                        else:
                            text_file.write("exact_result: %.16e %.16e\n"%(resultIntegration[n1,n2,2],resultIntegration[n1,n2,3]))
                        text_file.close()
                        
    return prefactor*result+bareSigma
Esempio n. 10
0
from PMFpack import *
from numpy import *
from pylab import *
from pygsl import integrate
from scipy.integrate import quad, dblquad, Inf
from scipy.special import erf, erfinv

w1 = integrate.workspace(10000)
w2 = integrate.workspace(10000)

#fmean = 0.639756248702123
#sigma = 0.16674922174125
#pmf = PMF(fmean, sigma, 0, 0, 0, 2)
#pmf.set_fmean_gradient(-0.4178939524532, 0, 0)  # Last two are zero because the simulation is 1D
#pmf.set_sigma_gradient(-0.5095137299633, 0, 0)
#pmf.chi = 0.38430391476813  # Mean scalar dissipation rate (defined with the factor 2)

#fmean = 0.32734785270559791
#sigma = 0.036258388156940768
#pmf = PMF(fmean, sigma, 0, 0, 0, 2)
#pmf.set_fmean_gradient(-0.40312611148071925, 0, 0)  # Last two are zero because the simulation is 1D
#pmf.set_sigma_gradient(-0.29357760186462173, 0, 0)
#pmf.chi = 0.36258388156940158  # Mean scalar dissipation rate (defined with the factor 2)

#fmean = 0.67265214729440204
#sigma = 0.036258388156940768
#pmf = PMF(fmean, sigma, 0, 0, 0, 2)
#pmf.set_fmean_gradient(-0.40312611148071925, 0, 0)  # Last two are zero because the simulation is 1D
#pmf.set_sigma_gradient(-0.51267462109681816, 0, 0)
#pmf.chi = 0.36258388156940158  # Mean scalar dissipation rate (defined with the factor 2)
Esempio n. 11
0
 def setUp(self):        
     self.w = integrate.workspace(1000000)