def sims3D():
    circrad = 0.01  #millimeters
    eps = 0.003
    zh = 2 * circrad
    halfzpts = 40
    X, Ves, Vrb, Vzline, zline = constructSolns(circrad, eps, zh, halfzpts,
                                                regSolnChainofSpheresNegExp)
    mydict = {
        'X': X,
        'Ves': Ves,
        'Vrb': Vrb,
        'circrad': circrad,
        'eps': eps,
        'zh': zh,
        'halfzpts': halfzpts
    }
    basedir = os.path.expanduser('~/CricketProject/CompReg2Exact/')
    basename = 'negexpspheres_BCsonaxis_zhdiameter_largereps40x2pts'
    F = open(os.path.join(basedir, basename + '.pickle'), 'w')
    cPickle.Pickler(F).dump(mydict)
    F.close()
    mydict = fo.loadPickle(basedir=basedir, basename=basename)
    graphSolns(mydict['X'], mydict['Ves'], mydict['Vrb'], mydict['circrad'],
               basedir, basename)
    vRS.plainPlots(zline, np.abs(Vzline[:, 0]), "|u|", "z", "velocity", None,
                   basedir + basename + '/zline_umag.pdf')
    vRS.plainPlots(zline, np.abs(Vzline[:, 1]), "|v|", "z", "velocity", None,
                   basedir + basename + '/zline_vmag.pdf')
    vRS.plainPlots(zline, np.abs(Vzline[:, 2]), "|w|", "z", "velocity", None,
                   basedir + basename + '/zline_wmag.pdf')
def sims3D():
    circrad = 0.01 #millimeters
    eps = 0.003
    zh = 2*circrad
    halfzpts = 40
    X, Ves, Vrb, Vzline,zline = constructSolns(circrad,eps,zh,halfzpts,regSolnChainofSpheresNegExp)
    mydict = {'X':X,'Ves':Ves,'Vrb':Vrb,'circrad':circrad,'eps':eps,'zh':zh,'halfzpts':halfzpts}
    basedir = os.path.expanduser('~/CricketProject/CompReg2Exact/')
    basename = 'negexpspheres_BCsonaxis_zhdiameter_largereps40x2pts'
    F = open( os.path.join(basedir,basename+'.pickle'), 'w' )
    cPickle.Pickler(F).dump(mydict)
    F.close()
    mydict = fo.loadPickle(basedir=basedir,basename=basename)    
    graphSolns(mydict['X'],mydict['Ves'],mydict['Vrb'],mydict['circrad'],basedir,basename)
    vRS.plainPlots(zline,np.abs(Vzline[:,0]),"|u|","z","velocity",None,basedir+basename+'/zline_umag.pdf')
    vRS.plainPlots(zline,np.abs(Vzline[:,1]),"|v|","z","velocity",None,basedir+basename+'/zline_vmag.pdf')
    vRS.plainPlots(zline,np.abs(Vzline[:,2]),"|w|","z","velocity",None,basedir+basename+'/zline_wmag.pdf')
def varyFreqEps_Drag(pdict, freqlist, epslist):
    xdrag_exact = []
    ydrag_exact = []
    xdrag_negex = [[] for j in range(len(freqlist))]
    ydrag_negex = [[] for j in range(len(freqlist))]
    xdrag_gauss = [[] for j in range(len(freqlist))]
    ydrag_gauss = [[] for j in range(len(freqlist))]
    #    xdrag_ncofs = [[] for j in range(len(freqlist))]
    #    ydrag_ncofs = [[] for j in range(len(freqlist))]
    #    xdrag_gcofs = [[] for j in range(len(freqlist))]
    #    ydrag_gcofs = [[] for j in range(len(freqlist))]
    for j in range(len(freqlist)):
        freq = freqlist[j]
        print("Freq=%d" % freq)
        alph = np.sqrt(1j * 2 * np.pi * freq / pdict['nu'])
        xdrag, ydrag = exactDragForces(pdict['circrad'], pdict['vh'], alph,
                                       pdict['mu'])
        xdrag_exact.append(xdrag)
        ydrag_exact.append(ydrag)
        for k in range(len(epslist)):
            eps = epslist[k]
            print("Eps=%f" % eps)
            rb, f = CRE.regSolnNegExpStokesletsOnly(pdict['nodes'], eps,
                                                    pdict['mu'], alph,
                                                    pdict['circrad'],
                                                    pdict['vh'])
            xd, yd = regDragForces(pdict, rb, f)
            xdrag_negex[j].append(xd)
            ydrag_negex[j].append(yd)
            rb, f = CRE.regSolnGaussianStokesletsOnly(pdict['nodes'], eps,
                                                      pdict['mu'], alph,
                                                      pdict['circrad'],
                                                      pdict['vh'])
            xd, yd = regDragForces(pdict, rb, f)
            xdrag_gauss[j].append(xd)
            ydrag_gauss[j].append(yd)


#            rb, f =   CRE.regSolnChainofSpheresNegExp(pdict['nodes'],eps,pdict['mu'],alph,pdict['circrad'],pdict['vh'])
#            xd,yd = calcRegSoln(pdict,rb,f)
#            xdrag_ncofs[j].append(xd)
#            ydrag_ncofs[j].append(yd)
#            rb, f = CRE.regSolnChainofSpheresGaussian(pdict['nodes'],eps,pdict['mu'],alph,pdict['circrad'],pdict['vh'])
#            xd, yd = calcRegSoln(pdict,rb,f)
#            xdrag_gcofs[j].append(xd)
#            ydrag_gcofs[j].append(yd)
        earr = np.asarray(epslist)
        #        xarrg = np.asarray([np.abs(xdrag_exact[j])*np.ones((len(epslist,))),np.abs(xdrag_gauss[j]),np.abs(xdrag_gcofs[j])]).transpose()
        #        yarrg = np.asarray([np.abs(ydrag_exact[j])*np.ones((len(epslist,))),np.abs(ydrag_gauss[j]),np.abs(ydrag_gcofs[j])]).transpose()
        #        xarrn = np.asarray([np.abs(xdrag_exact[j])*np.ones((len(epslist,))),np.abs(xdrag_negex[j]),np.abs(xdrag_ncofs[j])]).transpose()
        #        yarrn = np.asarray([np.abs(ydrag_exact[j])*np.ones((len(epslist,))),np.abs(ydrag_negex[j]),np.abs(ydrag_ncofs[j])]).transpose()
        xarr = np.asarray([
            np.abs(xdrag_exact[j]) * np.ones((len(epslist, ))),
            np.abs(xdrag_gauss[j]),
            np.abs(xdrag_negex[j])
        ]).transpose()
        yarr = np.asarray([
            np.abs(ydrag_exact[j]) * np.ones((len(epslist, ))),
            np.abs(ydrag_gauss[j]),
            np.abs(xdrag_negex[j])
        ]).transpose()
        #        vRS.plainPlots(earr,xarrg,'Magnitude x-drag','Epsilon','Drag',['exact','gauss','gauss spheres'],os.path.expanduser('~/scratch/xdrag_zhdiameter_gauss%03d.pdf' % freq))
        #        vRS.plainPlots(earr,yarrg,'Magnitude y-drag','Epsilon','Drag',['exact','gauss','gauss spheres'],os.path.expanduser('~/scratch/ydrag_zhdiameter_gauss%03d.pdf' % freq))
        #        vRS.plainPlots(earr,xarrn,'Magnitude x-drag','Epsilon','Drag',['exact','negex','negex spheres'],os.path.expanduser('~/scratch/xdrag_zhdiameter_negex%03d.pdf' % freq))
        #        vRS.plainPlots(earr,yarrn,'Magnitude y-drag','Epsilon','Drag',['exact','negex','negex spheres'],os.path.expanduser('~/scratch/ydrag_zhdiameter_negex%03d.pdf' % freq))
        vRS.plainPlots(
            earr, xarr, 'Magnitude x-drag', 'Epsilon', 'Drag',
            ['exact', 'gauss', 'negex'],
            os.path.expanduser(
                '~/CricketProject/ChooseEpsilon/xdrag_zhdiameter_freq%03d.pdf'
                % freq))
        vRS.plainPlots(
            earr, yarr, 'Magnitude y-drag', 'Epsilon', 'Drag',
            ['exact', 'gauss', 'negex'],
            os.path.expanduser(
                '~/CricketProject/ChooseEpsilon/ydrag_zhdiameter_freq%03d.pdf'
                % freq))
    return xdrag_exact, ydrag_exact, xdrag_negex, ydrag_negex, xdrag_gauss, ydrag_gauss
obspts[:,0] = np.linspace(zh/5,Nnodes*zh*0.75,Nobs)

#Exact solution
exactvel = lES.BrinkmanletsExact(obspts,nodes,f,alph,mu)

#Regularized solutions
eps = zh/2.
rbg = eRS.Brinkman3DGaussianStokeslets(eps,mu,alph)
regvelg = rbg.calcVel(obspts,nodes,f)
eps2 = (np.sqrt(np.pi)/56)**(1./3.) * eps #get the same limit as r->0
rbn = eRS.Brinkman3DNegExpStokeslets(eps2,mu,alph)
regveln = rbn.calcVel(obspts,nodes,f)
uvel = np.column_stack([exactvel[:,0],regvelg[:,0],regveln[:,0]])
vvel = np.column_stack([exactvel[:,1],regvelg[:,1],regveln[:,1]])
wvel = np.column_stack([exactvel[:,2],regvelg[:,2],regveln[:,2]])
vRS.plainPlots(obspts[:,0],np.abs(uvel),'Magnitude','x','speed',['Exact |u|','Gaussian |u|','Neg exp |u|'],os.path.expanduser('~/scratch/validation_umag.pdf'))
vRS.plainPlots(obspts[:,0],np.angle(uvel),'Phase','x','phase (rad)',['Exact ang(u)','Gaussian ang(u)','Neg exp ang(u)'],os.path.expanduser('~/scratch/validation_uang.pdf'))
vRS.plainPlots(obspts[:,0],np.abs(vvel),'Magnitude','x','speed',['Exact |v|','Gaussian |v|','Neg exp |v|'],os.path.expanduser('~/scratch/validation_vmag.pdf'))
vRS.plainPlots(obspts[:,0],np.angle(vvel),'Phase','x','phase (rad)',['Exact ang(v)','Gaussian ang(v)','Neg exp ang(v)'],os.path.expanduser('~/scratch/validation_vang.pdf'))
vRS.plainPlots(obspts[:,0],np.abs(wvel),'Magnitude','x','speed',['Exact |w|','Gaussian |w|','Neg exp |w|'],os.path.expanduser('~/scratch/validation_wmag.pdf'))
vRS.plainPlots(obspts[:,0],np.angle(wvel),'Phase','x','phase (rad)',['Exact ang(w)','Gaussian ang(w)','Neg exp ang(w)'],os.path.expanduser('~/scratch/validation_wang.pdf'))

#compare blobs
def gaussianblob(r,eps):
    return np.exp(-r**2/eps**2) / (np.pi**(3./2.)*eps**3)

def negexpblob(r,eps):
    return np.exp(-r/eps)*(r + 2*eps)**2 / (224*np.pi*eps**5)

def compactblob(r,eps):
    ind = np.nonzero(r<=eps)
#Exact solution
exactvel = lES.BrinkmanletsExact(obspts, nodes, f, alph, mu)

#Regularized solutions
eps = zh / 2.
rbg = eRS.Brinkman3DGaussianStokeslets(eps, mu, alph)
regvelg = rbg.calcVel(obspts, nodes, f)
eps2 = (np.sqrt(np.pi) / 56)**(1. / 3.) * eps  #get the same limit as r->0
rbn = eRS.Brinkman3DNegExpStokeslets(eps2, mu, alph)
regveln = rbn.calcVel(obspts, nodes, f)
uvel = np.column_stack([exactvel[:, 0], regvelg[:, 0], regveln[:, 0]])
vvel = np.column_stack([exactvel[:, 1], regvelg[:, 1], regveln[:, 1]])
wvel = np.column_stack([exactvel[:, 2], regvelg[:, 2], regveln[:, 2]])
vRS.plainPlots(obspts[:, 0], np.abs(uvel), 'Magnitude', 'x', 'speed',
               ['Exact |u|', 'Gaussian |u|', 'Neg exp |u|'],
               os.path.expanduser('~/scratch/validation_umag.pdf'))
vRS.plainPlots(obspts[:, 0], np.angle(uvel), 'Phase', 'x', 'phase (rad)',
               ['Exact ang(u)', 'Gaussian ang(u)', 'Neg exp ang(u)'],
               os.path.expanduser('~/scratch/validation_uang.pdf'))
vRS.plainPlots(obspts[:, 0], np.abs(vvel), 'Magnitude', 'x', 'speed',
               ['Exact |v|', 'Gaussian |v|', 'Neg exp |v|'],
               os.path.expanduser('~/scratch/validation_vmag.pdf'))
vRS.plainPlots(obspts[:, 0], np.angle(vvel), 'Phase', 'x', 'phase (rad)',
               ['Exact ang(v)', 'Gaussian ang(v)', 'Neg exp ang(v)'],
               os.path.expanduser('~/scratch/validation_vang.pdf'))
vRS.plainPlots(obspts[:, 0], np.abs(wvel), 'Magnitude', 'x', 'speed',
               ['Exact |w|', 'Gaussian |w|', 'Neg exp |w|'],
               os.path.expanduser('~/scratch/validation_wmag.pdf'))
vRS.plainPlots(obspts[:, 0], np.angle(wvel), 'Phase', 'x', 'phase (rad)',
               ['Exact ang(w)', 'Gaussian ang(w)', 'Neg exp ang(w)'],