karthik/Calculations
1
0
Fork 0
Code Issues Pull Requests repo.project_board Releases Wiki Activity

Compare commits

base: karthik:5f068db1c12abb6d5f61c74ed3370f7831b877b4
Branches Tags
karthik:master
..
compare: karthik:372690b158ab340955eac63ffbd6106d216e727f
Branches Tags
karthik:master

7 Commits
5f068db1c1 ... 372690b158

Author SHA1 Message Date
Karthik Chandrashekara
372690b158 New scripting 2021-08-19 12:44:54 +02:00
Karthik Chandrashekara
662eae4e03 Changed numerical values of some of the defaults and modifications were made for the bootstrap sample size and number to be user-defined. 2021-08-19 12:44:24 +02:00
Karthik Chandrashekara
8ac0a018f2 Removed the measurement of autocorrelation, modifications made for the bootstrap sample size and number to be user-defined. 2021-08-19 12:43:23 +02:00
Karthik Chandrashekara
e29c923723 Changed max limit of the number of atoms/trajectories to be computed from 20000 to 50000. 2021-08-19 12:41:11 +02:00
Karthik Chandrashekara
6a679bc26e Changed some numerical values in the defaults and corrected the calculation of the saturation parameter. 2021-08-19 12:40:25 +02:00
Karthik Chandrashekara
b520586f41 Dedicated script for investigating the use of sidebands to enhance the 2D-MOT loading rate. 2021-08-19 12:39:10 +02:00
Karthik Chandrashekara
cedbb008af Added line to plot contours. 2021-08-19 12:37:08 +02:00
7 changed files with 212 additions and 69 deletions
Show Stats Expand all files Collapse all files

4
+Plotter/plotResultForTwoParameterScan.m
View File

@ -47,6 +47,10 @@ function plotResultForTwoParameterScan(XParameter, YParameter, ZQuantity, vararg
imagesc(RescaledXParameter, RescaledYParameter, RescaledZQuantity(:,:)');
% hold on
%
% contour(RescaledXParameter, RescaledYParameter, RescaledZQuantity(:,:)', 'Color', 'r', 'Linewidth', 4, 'ShowText','on')
set(gca,'YDir','normal');
caxis([min(min(min(RescaledZQuantity))) max(max(max(RescaledZQuantity)))]);

92
+Scripts/optimizingForSidebandEnhancement.m
View File

@ -2,12 +2,12 @@ OptionsStruct = struct;
OptionsStruct.ErrorEstimationMethod = 'bootstrap'; % 'jackknife' | 'bootstrap'
OptionsStruct.NumberOfAtoms = 5000;
OptionsStruct.TimeStep = 50e-06; % in s
OptionsStruct.SimulationTime = 4e-03; % in s
OptionsStruct.SimulationTime = 5e-03; % in s
OptionsStruct.SpontaneousEmission = true;
OptionsStruct.SidebandBeam = true;
OptionsStruct.SidebandBeam = false;
OptionsStruct.PushBeam = true;
OptionsStruct.Gravity = true;
OptionsStruct.BackgroundCollision = true;
OptionsStruct.BackgroundCollision = false;
OptionsStruct.SaveData = true;
% OptionsStruct.SaveDirectory = '';
options = Helper.convertstruct2cell(OptionsStruct);
@ -15,18 +15,92 @@ clear OptionsStruct
Oven = Simulator.Oven(options{:});
MOT2D = Simulator.TwoDimensionalMOT(options{:});
Beams = MOT2D.Beams;
%%
MOT2D.NumberOfAtoms = 5000;
MOT2D.NumberOfAtoms = 10000;
MOT2D.TotalPower = 0.8;
MOT2D.MagneticGradient = 0.4; 0;
CoolingBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'Blue'), Beams)};
CoolingBeam.Waist = 15e-03;
CoolingBeam.Detuning = -1.67*Helper.PhysicsConstants.BlueLinewidth;
SidebandBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'BlueSideband'), Beams)};
SidebandBeam.Waist = 15e-03;
NumberOfPointsForFirstParam = 20; %iterations of the simulation
NumberOfPointsForSecondParam = 20;
DetuningArray = linspace(-1.0, -6.0, NumberOfPointsForFirstParam) * Helper.PhysicsConstants.BlueLinewidth;
PowerArray = linspace(0, 0.8, NumberOfPointsForSecondParam) * MOT2D.TotalPower;
tStart = tic;
[LoadingRateArray, ~, ~] = Scripts.scanForSidebandEnhancement(Oven, MOT2D, 'Blue', 'BlueSideband', DetuningArray, PowerArray);
tEnd = toc(tStart);
fprintf('Total Computational Time: %0.1f seconds. \n', tEnd);
if MOT2D.DoSave
LoadingRate = struct;
LoadingRate.Values = LoadingRateArray;
MOT2D.Results = LoadingRate;
SaveFolder = [MOT2D.SaveDirectory filesep 'Results'];
Filename = ['TwoParameterScan_' datestr(now,'yyyymmdd_HHMM')];
eval([sprintf('%s_Object', Filename) ' = MOT2D;']);
mkdir(SaveFolder);
save([SaveFolder filesep Filename], sprintf('%s_Object', Filename));
end
MOT2D.SidebandBeam = false;
MOT2D.PushBeam = false;
CoolingBeam.Power = MOT2D.TotalPower;
[LoadingRate, ~] = MOT2D.runSimulation(Oven);
EnhancementFactorArray = LoadingRateArray ./ LoadingRate;
% - Plot results
OptionsStruct = struct;
OptionsStruct.RescalingFactorForFirstParameter = (Helper.PhysicsConstants.BlueLinewidth)^-1;
OptionsStruct.XLabelString = 'Sideband Beam Detuning (\Delta/\Gamma)';
OptionsStruct.RescalingFactorForSecondParameter = 1000;
OptionsStruct.YLabelString = 'Sideband Beam Power (mW)';
OptionsStruct.RescalingFactorForQuantityOfInterest = 1;
OptionsStruct.ZLabelString = 'Enhancement Factor (\eta)';
% OptionsStruct.ZLabelString = 'Loading rate (x 10^{9} atoms/s)';
OptionsStruct.TitleString = sprintf('Magnetic Gradient = %.0f (G/cm)', MOT2D.MagneticGradient * 100);
options = Helper.convertstruct2cell(OptionsStruct);
Plotter.plotResultForTwoParameterScan(DetuningArray, PowerArray, EnhancementFactorArray, options{:})
%% Magnetic gradient scan
MOT2D.NumberOfAtoms = 10000;
MOT2D.TotalPower = 0.4;
MOT2D.SidebandBeam = true;
NumberOfPointsForFirstParam = 10; %iterations of the simulation
NumberOfPointsForSecondParam = 10;
NumberOfPointsForThirdParam = 6;
DetuningArray = linspace(-0.5, -5.0, NumberOfPointsForFirstParam) * Helper.PhysicsConstants.BlueLinewidth;
PowerArray = linspace(0.1, 1.0, NumberOfPointsForSecondParam) * MOT2D.TotalPower;
MagneticGradientArray = linspace(30, 50, NumberOfPointsForThirdParam) * 1e-02;
Beams = MOT2D.Beams;
CoolingBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'Blue'), Beams)};
SidebandBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'BlueSideband'), Beams)};
LoadingRateArray = {};
tStart = tic;
[LoadingRateArray, ~, ~] = Scripts.scanForSidebandEnhancement(Oven, MOT2D, 'Blue', 'BlueSideband', DetuningArray, PowerArray);
for k=1:NumberOfPointsForThirdParam
eval(sprintf('MOT2D.%s = %d;', 'MagneticGradient', MagneticGradientArray(k)));
lrmatrix = zeros(NumberOfPointsForFirstParam, NumberOfPointsForSecondParam);
for i=1:NumberOfPointsForFirstParam
eval(sprintf('SidebandBeam.%s = %d;', 'Detuning', DetuningArray(i)));
for j=1:NumberOfPointsForSecondParam
eval(sprintf('SidebandBeam.%s = %d;', 'Power', PowerArray(j)));
eval(sprintf('CoolingBeam.%s = %d;', 'Power', MOT2D.TotalPower - PowerArray(j)));
[lrmatrix(i,j), ~, ~] = MOT2D.runSimulation(Oven);
end
end
LoadingRateArray{end+1} = lrmatrix;
end
tEnd = toc(tStart);
fprintf('Total Computational Time: %0.1f seconds. \n', tEnd);
@ -36,13 +110,15 @@ OptionsStruct = struct;
OptionsStruct.RescalingFactorForFirstParameter = (Helper.PhysicsConstants.BlueLinewidth)^-1;
OptionsStruct.XLabelString = 'Sideband Beam Detuning (\Delta/\Gamma)';
OptionsStruct.RescalingFactorForSecondParameter = 1000;
OptionsStruct.YLabelString = 'Sideband Beam Power (mW)';
OptionsStruct.YLabelString = 'Sideband Beam Waist (mm)';
OptionsStruct.RescalingFactorForThirdParameter = 100;
OptionsStruct.RescalingFactorForQuantityOfInterest = 1e-9;
OptionsStruct.ZLabelString = 'Loading rate (x 10^{9} atoms/s)';
OptionsStruct.TitleString = sprintf('Magnetic Gradient = %.0f (G/cm)', MOT2D.MagneticGradient * 100);
OptionsStruct.PlotTitleString = 'Magnetic Gradient = %.0f (G/cm)';
OptionsStruct.FigureTitleString = sprintf('Oven-2DMOT Distance = %.1f (mm); Total Beam Power = %d (mW)', Oven.OvenDistance * 1000, MOT2D.TotalPower*1000);
options = Helper.convertstruct2cell(OptionsStruct);
Plotter.plotResultForTwoParameterScan(DetuningArray, PowerArray, LoadingRateArray, options{:})
Plotter.plotResultForThreeParameterScan(DetuningArray, PowerArray, MagneticGradientArray, LoadingRateArray, options{:})
clear OptionsStruct

20
+Simulator/@Beams/Beams.m
View File

@ -4,9 +4,9 @@ classdef Beams < handle & matlab.mixin.Copyable
BlueBeamDefault = struct('Alias', 'Blue', ...
'Power', 400e-3, ...
'Detuning', -1.39*Helper.PhysicsConstants.BlueLinewidth, ...
'Radius', 35e-3, ...
'Waist', 16.67e-3, ...
'Detuning', -1.64*Helper.PhysicsConstants.BlueLinewidth, ...
'Radius', 17.5e-3, ...
'Waist', 15e-3, ...
'WaveNumber',2*pi/Helper.PhysicsConstants.BlueWavelength, ...
'Linewidth', Helper.PhysicsConstants.BlueLinewidth, ...
'SaturationIntensity', 0.1 * (2 * pi^2 / 3) * ...
@ -15,10 +15,10 @@ classdef Beams < handle & matlab.mixin.Copyable
Helper.PhysicsConstants.BlueLinewidth) / (Helper.PhysicsConstants.BlueWavelength)^3));
BlueSidebandBeamDefault = struct('Alias', 'BlueSideband', ...
'Power', 200e-3, ...
'Power', 400e-3, ...
'Detuning', -3*Helper.PhysicsConstants.BlueLinewidth, ...
'Radius', 35e-3, ...
'Waist', 16.67e-3, ...
'Radius', 17.5e-3, ...
'Waist', 15e-3, ...
'WaveNumber',2*pi/Helper.PhysicsConstants.BlueWavelength, ...
'Linewidth', Helper.PhysicsConstants.BlueLinewidth, ...
'SaturationIntensity', 0.1 * (2 * pi^2 / 3) * ...
@ -27,10 +27,10 @@ classdef Beams < handle & matlab.mixin.Copyable
Helper.PhysicsConstants.BlueLinewidth) / (Helper.PhysicsConstants.BlueWavelength)^3));
PushBeamDefault = struct('Alias', 'Push', ...
'Power', 10e-3 , ...
'Detuning', 0*Helper.PhysicsConstants.RedLinewidth, ...
'Power', 25e-3 , ...
'Detuning', 104.2*Helper.PhysicsConstants.RedLinewidth, ...
'Radius', 1.2e-03, ...
'Waist', 20.001e-3, ...
'Waist', 1.0e-03, ...
'WaveNumber',2*pi/Helper.PhysicsConstants.RedWavelength, ...
'Linewidth', Helper.PhysicsConstants.RedLinewidth, ...
'SaturationIntensity', 0.1 * (2 * pi^2 / 3) * ...
@ -163,7 +163,7 @@ classdef Beams < handle & matlab.mixin.Copyable
methods
function ret = get.SaturationParameter(this)
ret = 0.1 * (4 * this.Power) / (pi*this.Waist^2 * this.SaturationIntensity); % two beams are reflected
ret = 0.1 * (8 * this.Power) / (pi*this.Waist^2 * this.SaturationIntensity); % two beams are reflected
end
end % - getters for dependent properties

2
+Simulator/@MOTCaptureProcess/MOTCaptureProcess.m
View File

@ -108,7 +108,7 @@ classdef MOTCaptureProcess < handle & matlab.mixin.Copyable
ret = this.SimulationTime;
end
function set.NumberOfAtoms(this, val)
assert(val <= 20000, 'Not time efficient to compute for atom numbers larger than 20,000!');
assert(val <= 50000, '!!Not time efficient to compute for atom numbers larger than 50,000!!');
this.NumberOfAtoms = val;
end
function ret = get.NumberOfAtoms(this)

21
+Simulator/@TwoDimensionalMOT/TwoDimensionalMOT.m
View File

@ -1,8 +1,8 @@
classdef TwoDimensionalMOT < Simulator.MOTCaptureProcess & matlab.mixin.Copyable
properties (Access = private)
MagneticGradienDefault = 0.425; % T/m
ExitDivergenceDefault = 16e-3;
MagneticGradienDefault = 0.40; % T/m
ExitDivergenceDefault = 15e-3;
DistanceBetweenPushBeamAnd3DMOTCenterDefault = 0;
PushBeamDistanceDefault = 0.32;
end
@ -19,6 +19,8 @@ classdef TwoDimensionalMOT < Simulator.MOTCaptureProcess & matlab.mixin.Copyable
TimeSpentInInteractionRegion;
ParticleDynamicalQuantities;
InitialParameters;
BootstrapSampleLength;
BootstrapSampleNumber;
Results;
end
@ -50,7 +52,8 @@ classdef TwoDimensionalMOT < Simulator.MOTCaptureProcess & matlab.mixin.Copyable
this.InitialParameters.LandegFactor = this.LandegFactor;
this.InitialParameters.MagneticSubLevel= this.MagneticSubLevel;
this.InitialParameters.MagneticGradient= this.MagneticGradient;
this.BootstrapSampleLength = 0.5 * this.NumberOfAtoms;
this.BootstrapSampleNumber = 1000;
end
function restoreDefaults(this)
@ -131,6 +134,18 @@ classdef TwoDimensionalMOT < Simulator.MOTCaptureProcess & matlab.mixin.Copyable
function ret = get.InitialParameters(this)
ret = this.InitialParameters;
end
function set.BootstrapSampleLength(this,val)
this.BootstrapSampleLength = val;
end
function ret = get.BootstrapSampleLength(this)
ret = this.BootstrapSampleLength;
end
function set.BootstrapSampleNumber(this,val)
this.BootstrapSampleNumber = val;
end
function ret = get.BootstrapSampleNumber(this)
ret = this.BootstrapSampleNumber;
end
function set.Results(this, val)
this.Results = val;
end

55
+Simulator/@TwoDimensionalMOT/bootstrapErrorEstimation.m
View File

@ -1,39 +1,22 @@
function [LoadingRate, StandardError, ConfidenceInterval] = bootstrapErrorEstimation(this, ovenObj, NumberOfLoadedAtoms)
n = this.NumberOfAtoms;
NumberOfTimeSteps = int64(this.SimulationTime/this.TimeStep);
Autocorrelation = autocorr(NumberOfLoadedAtoms,'NumLags', double(NumberOfTimeSteps - 1));
if Autocorrelation(1)~=0
CorrelationFactor = table(Helper.findAllZeroCrossings(linspace(1, double(NumberOfTimeSteps), double(NumberOfTimeSteps)), Autocorrelation)).Var1(1);
if ~isnan(CorrelationFactor)
SampleLength = floor(CorrelationFactor);
NumberOfBootsrapSamples = 1000;
MeanCaptureRatioInEachSample = zeros(1,NumberOfBootsrapSamples);
for SampleNumber = 1:NumberOfBootsrapSamples
BoostrapSample = datasample(NumberOfLoadedAtoms, SampleLength); % Sample with replacement
MeanCaptureRatioInEachSample(SampleNumber) = mean(BoostrapSample) / n; % Empirical bootstrap distribution of sample means
end
LoadingRate = mean(MeanCaptureRatioInEachSample) * ovenObj.ReducedFlux;
Variance = 0; % Bootstrap Estimate of Variance
for SampleNumber = 1:NumberOfBootsrapSamples
Variance = Variance + (MeanCaptureRatioInEachSample(SampleNumber) - mean(MeanCaptureRatioInEachSample))^2;
end
StandardError = sqrt((1 / (NumberOfBootsrapSamples-1)) * Variance) * ovenObj.ReducedFlux;
ts = tinv([0.025 0.975],NumberOfBootsrapSamples-1); % T-Score
ConfidenceInterval = LoadingRate + ts*StandardError; % 95% Confidence Intervals
else
LoadingRate = nan;
StandardError = nan;
ConfidenceInterval = [nan nan];
end
else
LoadingRate = nan;
StandardError = nan;
ConfidenceInterval = [nan nan];
n = this.NumberOfAtoms;
SampleLength = this.BootstrapSampleLength;
NumberOfBootsrapSamples = this.BootstrapSampleNumber;
MeanCaptureRatioInEachSample = zeros(1,NumberOfBootsrapSamples);
for SampleNumber = 1:NumberOfBootsrapSamples
BoostrapSample = datasample(NumberOfLoadedAtoms, SampleLength); % Sample with replacement
MeanCaptureRatioInEachSample(SampleNumber) = mean(BoostrapSample) / n; % Empirical bootstrap distribution of sample means
end
LoadingRate = mean(MeanCaptureRatioInEachSample) * ovenObj.ReducedFlux;
Variance = 0; % Bootstrap Estimate of Variance
for SampleNumber = 1:NumberOfBootsrapSamples
Variance = Variance + (MeanCaptureRatioInEachSample(SampleNumber) - mean(MeanCaptureRatioInEachSample))^2;
end
StandardError = sqrt((1 / (NumberOfBootsrapSamples-1)) * Variance) * ovenObj.ReducedFlux;
ts = tinv([0.025 0.975],NumberOfBootsrapSamples-1); % T-Score
ConfidenceInterval = LoadingRate + ts*StandardError; % 95% Confidence Intervals
end

87
test_MOTCaptureProcessSimulation.m
View File

@ -26,11 +26,16 @@ Beams = MOT2D.Beams;
%% - Run Simulation
MOT2D.NumberOfAtoms = 5000;
MOT2D.SidebandBeam = false;
MOT2D.SidebandBeam = true;
MOT2D.PushBeam = false;
CoolingBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'Blue'), Beams)};
CoolingBeam.Power = 0.4;
CoolingBeam.Waist = 13.3e-03;
CoolingBeam.Detuning = -1.67*Helper.PhysicsConstants.BlueLinewidth;
CoolingBeam.Power = 0.2;
CoolingBeam.Waist = 16.67e-03;
CoolingBeam.Detuning = -1.33*Helper.PhysicsConstants.BlueLinewidth;
SidebandBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'BlueSideband'), Beams)};
SidebandBeam.Power = 0.4;
SidebandBeam.Waist = 16.67e-03;
SidebandBeam.Detuning = -2.66*Helper.PhysicsConstants.BlueLinewidth;
PushBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'Push'), Beams)};
PushBeam.Power = 0.025;
PushBeam.Waist = 0.81e-03;
@ -73,10 +78,12 @@ Plotter.plotCaptureVelocityVsAngle(Oven, MOT2D); % Takes a long time to plot!
MOT2D.SidebandBeam = true;
CoolingBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'Blue'), Beams)};
CoolingBeam.Power = 0.2;
CoolingBeam.Detuning = -1.67*Helper.PhysicsConstants.BlueLinewidth;
CoolingBeam.Detuning = -1.5*Helper.PhysicsConstants.BlueLinewidth;
CoolingBeam.Waist = 16e-03;
SidebandBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'BlueSideband'), Beams)};
SidebandBeam.Power = 0.2;
SidebandBeam.Detuning = -3.35*Helper.PhysicsConstants.BlueLinewidth;
SidebandBeam.Power = 0.6;
SidebandBeam.Detuning = -5*Helper.PhysicsConstants.BlueLinewidth;
SidebandBeam.Waist = 16e-03;
MOT2D.NumberOfAtoms = 50;
MinimumVelocity = 0;
MaximumVelocity = 150;
@ -102,6 +109,8 @@ Plotter.plotDynamicalQuantities(Oven, MOT2D, MaximumVelocity, IncidentAtomDirect
MOT2D.NumberOfAtoms = 5000;
MOT2D.TotalPower = 0.4;
MOT2D.SidebandBeam = false;
MOT2D.PushBeam = false;
NumberOfPointsForFirstParam = 5; %iterations of the simulation
ParameterArray = linspace(0.1, 1.0, NumberOfPointsForFirstParam) * MOT2D.TotalPower;
@ -130,6 +139,56 @@ Plotter.plotResultForOneParameterScan(ParameterArray, LoadingRateArray, options{
clear OptionsStruct
%% - Scan parameters: One-Parameter Scan
MOT2D.NumberOfAtoms = 10000;
CoolingBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'Blue'), Beams)};
CoolingBeam.Power = 0.4;
MOT2D.SidebandBeam = false;
MOT2D.PushBeam = false;
% ParameterArray = [10 20 30 40 50 60 70 80 90 100];
ParameterArray = [500 1000 1500 2000 2500 3000 3500 4000 4500 5000 5500 6000 6500 7000 7500 8000 8500 9000 9500];
NumberOfPointsForParam = length(ParameterArray); %iterations of the simulation
LoadingRateArray = zeros(1,NumberOfPointsForParam);
StandardErrorArray = zeros(1,NumberOfPointsForParam);
ConfidenceIntervalArray = zeros(NumberOfPointsForParam, 2);
tStart = tic;
for i=1:NumberOfPointsForParam
MOT2D.BootstrapSampleLength = ParameterArray(i);
[LoadingRateArray(i), StandardErrorArray(i), ConfidenceIntervalArray(i,:)] = MOT2D.runSimulation(Oven);
end
tEnd = toc(tStart);
fprintf('Total Computational Time: %0.1f seconds. \n', tEnd);
% - Plot results
OptionsStruct = struct;
OptionsStruct.RescalingFactorForParameter = 1;
OptionsStruct.XLabelString = 'Bootstrap Sample Length';
OptionsStruct.RescalingFactorForYQuantity = 1e-10;
OptionsStruct.ErrorsForYQuantity = true;
OptionsStruct.ErrorsArray = StandardErrorArray;
OptionsStruct.CIForYQuantity = true;
OptionsStruct.CIArray = ConfidenceIntervalArray;
OptionsStruct.RemoveOutliers = false;
OptionsStruct.YLabelString = 'Loading rate (x 10^{10} atoms/s)';
OptionsStruct.TitleString = sprintf('Cooling Beam Power = %d (mW); Magnetic Gradient = %.0f (G/cm)', CoolingBeam.Power*1000, MOT2D.MagneticGradient * 100);
options = Helper.convertstruct2cell(OptionsStruct);
Plotter.plotResultForOneParameterScan(ParameterArray, LoadingRateArray, options{:})
MeanLR = mean(LoadingRateArray(:)) * 1e-10;
yline(MeanLR, 'LineStyle', '--', 'Linewidth', 2.5)
textstring = [sprintf('%1.2e', MeanLR * 1e+10) ' atoms'];
% txt = text((ParameterArray(2) + 0.05*ParameterArray(2)), (max(MeanLR) + 0.05*MeanLR), textstring, 'Interpreter','latex', 'FontSize', 14);
% xlim([0 100])
ylim([0 3.5])
clear OptionsStruct
%% - Scan parameters: Two-Parameter Scan
% COOLING BEAM POWER VS DETUNING
@ -164,9 +223,12 @@ Plotter.plotResultForTwoParameterScan(FirstParameterArray, SecondParameterArray,
clear OptionsStruct
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% COOLING BEAM WAIST VS DETUNING
%% COOLING BEAM WAIST VS DETUNING
MOT2D.NumberOfAtoms = 5000;
MOT2D.NumberOfAtoms = 20000;
MOT2D.MagneticGradient = 0.38;
MOT2D.SidebandBeam = false;
MOT2D.PushBeam = false;
CoolingBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'Blue'), Beams)};
CoolingBeam.Power = 0.4;
NumberOfPointsForFirstParam = 10; %iterations of the simulation
@ -200,15 +262,18 @@ clear OptionsStruct
% COOLING BEAM WAIST VS DETUNING FOR DIFFERENT MAGNETIC FIELD GRADIENTS
MOT2D.NumberOfAtoms = 5000;
MOT2D.NumberOfAtoms = 10000;
MOT2D.SidebandBeam = false;
MOT2D.PushBeam = false;
CoolingBeam = Beams{cellfun(@(x) strcmpi(x.Alias, 'Blue'), Beams)};
CoolingBeam.Power = 0.4;
CoolingBeam.Power = 0.7;
NumberOfPointsForFirstParam = 10; %iterations of the simulation
NumberOfPointsForSecondParam = 10;
NumberOfPointsForThirdParam = 6;
FirstParameterArray = linspace(-0.5, -2.0, NumberOfPointsForFirstParam) * Helper.PhysicsConstants.BlueLinewidth;
SecondParameterArray = linspace(10, 25, NumberOfPointsForSecondParam) * 1e-03;
ThirdParameterArray = linspace(30, 50, NumberOfPointsForThirdParam) * 1e-02;
MOT2D.BootstrapSampleLength = 500;
tStart = tic;
LoadingRateArray = Simulator.Scan.doThreeParameters(Oven, MOT2D, 'Blue', 'Detuning', FirstParameterArray, ...