def runIt(g_C, R, gamma_C, a, width, diffusionLength, rMiddle, P):
"""
Do a simulation, plot and save a diagnostic plot.
"""
if singleComp:
ringParams = Simulator.ParameterContainer(g_C=g_C,
g_R=2.0 * g_C,
gamma_nl=gamma_nl,
gamma_C=gamma_C,
gamma_R=a * gamma_C,
R=R,
m=m,
charL=charL,
charT=charT)
else:
ringParams = Simulator.ParameterContainer(g_C=g_C,
g_R=2.0 * g_C,
gamma_C=gamma_C,
gamma_R=a * gamma_C,
R=R,
m=m,
charL=charL,
charT=charT)
params = ringParams.getGPEParams()
print params
Pth = params["Pth"]
# --- Grid, associated quantities ---
grid = Simulator.Grid(ringParams.charL, max_XY=max_XY_unscaled, N=N)
sigma = grid.toPixels(diffusionLength)
x, y = grid.getSpatialGrid()
x_us, y_us = grid.getSpatialGrid(scaled=False)
dx = grid.dx_scaled
# Time to record spectrum to. This will ensure that we have a resolution of
# at least 0.01 meV
spectMax = int(5e-6 / grid.dx_unscaled)
# Mask for collection of spectrum and energy. This will ensure that we only
# collect from the center of the ring
mask = x_us**2 + y_us**2 > (5e-6)**2
# --- Initial wavefunction ---
# Gaussian in the middle of the trap
psi0 = UtilityFunctions.GaussianPump(0.2*rMiddle,
0.1, 1, exponent=1.1).\
scaledFunction(ringParams.charL)
pump = UtilityFunctions.AnnularPumpFlat(rMiddle,
width,
P,
Pth,
sigma=sigma)
# Since we used Pth from params, the pump will be in units of
# L_C^-2 * T_C^-1
pumpFunction = pump.scaledFunction(ringParams.charL)
# P0 = np.max(pumpFunction(x, y))
# print P0
# stabParam = (P0 / params['Pth']) / ((params['g_R'] * params['gamma_C'])
# / (params['g_C'] *
# params['gamma_R']))
# print("Stability parameter %f (should be > 1)" % stabParam)
numStabParam = (np.pi * dt) / dx**2
if numStabParam >= 0.8:
print(
"Warning, numerical stability parameter is %.4f \n Should be <1 " %
numStabParam)
print("Numerical Stability Parameter %f (should be < 1)" %
((np.pi * dt) / dx**2))
solver = Simulator.GPESolver(ringParams,
dt,
grid,
pumpFunction=pumpFunction,
psiInitial=psi0,
REAL_DTYPE=np.float64,
COMPLEX_DTYPE=np.complex128)
solver.stepTo(T_MAX,
stepsPerObservation=1000,
spectStart=T_STABLE,
normalized=False,
spectLength=spectLength,
printTime=False,
collectionMask=mask,
spectMax=spectMax)
f = diagnosticPlot(solver)
f.savefig("PScanSingle " + getPlotName(ringParams, P=P) + ".png", dpi=500)
# f.savefig("testPlot" + ".png", dpi=600)
# solver.save("testPlot", P=P)
solver.save("PScanSingle " +
getPlotName(ringParams.getOutputParams(), P=P),
P=P)
plt.close(f)
gamma_C = gamma_C.to_base_units().magnitude
gamma_R = 4.0 * gamma_C
R = (0.05 * ureg.millielectron_volt * ureg.micrometer * ureg.micrometer) / hbar
R = R.to_base_units().magnitude
# Wouters does not provide m. Let us assume it is 10e-4 m_e
m = 10e-4
woutersParams = Simulator.ParameterContainer(g_C=g_C, g_R=g_R, gamma_C=gamma_C,
gamma_R=gamma_R, R=R, m=m)
params = woutersParams.getGPEParams()
# Pump parameters for small and large spots from Wouters
# P0 are both in units of Pth
P0_large = 2.0
P0_small = 8.0
sigma_large = (20.0 * ureg.micrometer).to_base_units().magnitude
sigma_small = (2.0 * ureg.micrometer).to_base_units().magnitude
# Make pumps
largePump = UtilityFunctions.GaussianPump(sigma_large, P0_large,
params['Pth'])
largePumpFunction = largePump.scaledFunction(woutersParams.charL)
smallPump = UtilityFunctions.GaussianPump(sigma_small, P0_small,
params['Pth'])
smallPumpFunction = smallPump.scaledFunction(woutersParams.charL)
# Make Grid
grid = Simulator.Grid(woutersParams.charL, max_XY=max_XY_unscaled, N=N)
# solver = Simulator.GPESolver(grid.getSpatialGrid(), grid.getkGrid(),
# N_THREADS=1)
def runIt(g_C, R, width, rMiddle, P):
"""
Do a simulation, plot and save a diagnostic plot.
"""
# if rMiddle <= 10 * ureg.micrometer.to_base_units().magnitude:
# N = 512
# else:
# N = 1024
ringParams = Simulator.ParameterContainer(g_C=g_C,
g_R=2.0 * g_C,
gamma_C=gamma_C,
gamma_R=a * gamma_C,
R=R,
m=m,
charL=charL,
charT=charT)
# ringParams = Simulator.ParameterContainer(g_C=g_C, g_R=2.0*g_C,
# gamma_C=gamma_C,
# gamma_R=a*gamma_C, R=R, m=m)
params = ringParams.getGPEParams()
# params['charT'] = ringParams.charT
P0 = P * params['Pth']
# Make Grid
# grid = Simulator.Grid(ringParams.charL, max_XY=max_XY_unscaled, N=N)
# grid = Simulator.Grid(ringParams.charL, max_XY=3.0 * (rMiddle + width), N=N)
grid = Simulator.Grid(ringParams.charL,
max_XY=2.0 * (rMiddle + width),
N=N)
sigma = grid.toPixels(diffusionLength)
x, y = grid.getSpatialGrid()
x_us, y_us = grid.getSpatialGrid(scaled=False)
pump = UtilityFunctions.AnnularPumpFlat(rMiddle,
width,
P,
params['Pth'],
sigma=sigma)
# pump = UtilityFunctions.AnnularPumpGaussian(rMiddle, P, params['Pth'],
# sigma=width)
# pump = UtilityFunctions.GaussianPump(rMiddle, P, params['Pth'])
pumpFunction = pump.scaledFunction(ringParams.charL)
P0 = np.max(pumpFunction(x, y))
stabParam = (P0 / params['Pth']) / ((params['g_R'] * params['gamma_C']) /
(params['g_C'] * params['gamma_R']))
# Gaussian in the middle of the trap
psi0 = UtilityFunctions.GaussianPump(0.2*rMiddle,
0.01, 1, exponent=1.1).\
scaledFunction(ringParams.charL)
# psi0 = lambda x, y: 0.01 * pumpFunction(x, y) / P0
print("Stability parameter %f (should be > 1)" % stabParam)
dx = grid.dx_scaled
print("Numerical Stability Parameter %f (should be < 1)" %
((np.pi * dt) / dx**2))
print("P = %f" % P)
print("Pth = %f" % params['Pth'])
print("P0 = %f" % P0)
print("P0/Pth = %f" % (P0 / params['Pth']))
solver = Simulator.GPESolver(params,
dt,
grid.getSpatialGrid(),
grid.getKSquaredGrid(),
pumpFunction,
psiInitial=psi0,
gpu=True)
energyTimes, energy = solver.stepTo(T_MAX, stepsPerObservation=100)
# solver.stepTo(T_MAX, stepsPerObservation=1000)
f = diagnosticPlot(1e6 * x_us, 1e6 * y_us, solver, energyTimes, energy,
pump.scaledFunction(charL=1e-6))
f.savefig("Snoke" +
getPlotName(params, r=rMiddle, m=m, sigma=diffusionLength) +
".png",
dpi=800)
# f.savefig("testNew" + ".png", dpi=800)
plt.close(f)
