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

Rewriting of gradient descent algorithm - follows Santo Roccuzzo's implementation.

Browse Source
This commit is contained in:
Karthik 2025-04-01 00:50:03 +02:00
parent 7aa4c7801b
commit 86b74b30da
2 changed files with 35 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Dipolar-Gas-Simulator/+Simulator/@DipolarGas/DipolarGas.m
View File

@ -17,7 +17,7 @@ classdef DipolarGas < handle & matlab.mixin.Copyable
EnergyTolerance; EnergyTolerance;
ResidualTolerance; ResidualTolerance;
NoiseScaleFactor; NoiseScaleFactor;
MaxIterationsForCGD; MaxIterationsForGD;
Calculator; Calculator;
@ -70,7 +70,7 @@ classdef DipolarGas < handle & matlab.mixin.Copyable
@(x) assert(isnumeric(x) && isscalar(x) && (x > 0))); @(x) assert(isnumeric(x) && isscalar(x) && (x > 0)));
addParameter(p, 'NoiseScaleFactor', 4,... addParameter(p, 'NoiseScaleFactor', 4,...
@(x) assert(isnumeric(x) && isscalar(x) && (x > 0))); @(x) assert(isnumeric(x) && isscalar(x) && (x > 0)));
addParameter(p, 'MaxIterationsForCGD', 100,... addParameter(p, 'MaxIterationsForGD', 100,...
@(x) assert(isnumeric(x) && isscalar(x) && (x > 0))); @(x) assert(isnumeric(x) && isscalar(x) && (x > 0)));
addParameter(p, 'IncludeDDICutOff', true,... addParameter(p, 'IncludeDDICutOff', true,...
@ -107,7 +107,7 @@ classdef DipolarGas < handle & matlab.mixin.Copyable
this.EnergyTolerance = p.Results.EnergyTolerance; this.EnergyTolerance = p.Results.EnergyTolerance;
this.ResidualTolerance = p.Results.ResidualTolerance; this.ResidualTolerance = p.Results.ResidualTolerance;
this.NoiseScaleFactor = p.Results.NoiseScaleFactor; this.NoiseScaleFactor = p.Results.NoiseScaleFactor;
this.MaxIterationsForCGD = p.Results.MaxIterationsForCGD; this.MaxIterationsForGD = p.Results.MaxIterationsForGD;
this.IncludeDDICutOff = p.Results.IncludeDDICutOff; this.IncludeDDICutOff = p.Results.IncludeDDICutOff;
this.UseApproximationForLHY = p.Results.UseApproximationForLHY; this.UseApproximationForLHY = p.Results.UseApproximationForLHY;

124
Dipolar-Gas-Simulator/+Simulator/@DipolarGas/minimizeEnergyFunctional.m
View File

@ -1,20 +1,14 @@
function [psi] = minimizeEnergyFunctional(this,psi,Params,Transf,VDk,V,Observ) function [psi] = runGradientDescent(this,psi,Params,Transf,VDk,V,Observ)
format long; format long;
% Define the function handle
f = @(X) this.Calculator.calculateTotalEnergy(X, Params, Transf, VDk, V)/Params.N;
% Convergence Criteria: % Convergence Criteria:
Epsilon = 1E-5; epsilon = 1E-8;
alpha = 1E-4;
% Iteration Counter: beta = 0.9;
i = 1;
Observ.residual = 1;
Observ.res = 1;
% Initialize the PrematureExitFlag to false Observ.residual = 1;
PrematureExitFlag = false; psi_old = psi; % Previous psi value (for heavy-ball method)
if this.PlotLive if this.PlotLive
Plotter.plotLive(psi,Params,Transf,Observ) Plotter.plotLive(psi,Params,Transf,Observ)
@ -22,56 +16,40 @@ function [psi] = minimizeEnergyFunctional(this,psi,Params,Transf,VDk,V,Observ)
end end
% Minimization Loop % Minimization Loop
while true for idx = 1:this.MaxIterationsForGD
% Compute gradient % Compute gradient
J = compute_gradient(psi, Params, Transf, VDk, V); J = compute_gradient(psi, Params, Transf, VDk, V);
% Check stopping criterion (Gradient norm) % Calculate chemical potential and norm
if norm(J(:)) < Epsilon muchem = sum(real(conj(psi) .* J)) / sum(abs(psi).^2);
disp('Tolerance reached: Gradient norm is below the specified epsilon.');
PrematureExitFlag = true; % Set flag to indicate premature exit % Calculate residual and check convergence
break; residual = sum(abs(J - muchem * psi).^2) * Transf.dx * Transf.dy * Transf.dz;
elseif i >= this.MaxIterationsForCGD if residual < epsilon
disp('Maximum number of iterations for CGD reached.'); fprintf('Convergence reached at iteration %d\n', idx);
PrematureExitFlag = true; % Set flag to indicate premature exit
break; break;
end end
% Initialize search direction if first iteration % Update psi using heavy-ball method
if i == 1 psi_new = (1 + beta) * psi - alpha * J - beta * psi_old;
S = -J; psi_old = psi;
else
% Update search direction
S = update_search_direction(S, J, J_old);
end
% Step Size Optimization (Line Search)
alpha = optimize_step_size(f, psi, S, Params, Transf, VDk, V);
% Update solution
psi = psi + alpha * S;
% Normalize psi % Normalize psi
Norm = sum(abs(psi(:)).^2) * Transf.dx * Transf.dy * Transf.dz; Norm = sum(abs(psi_new(:)).^2) * Transf.dx * Transf.dy * Transf.dz;
psi = sqrt(Params.N) * psi / sqrt(Norm); psi = sqrt(Params.N) * psi_new / sqrt(Norm);
% Store old gradient if mod(idx,500) == 0
J_old = J;
i = i + 1;
muchem = this.Calculator.calculateChemicalPotential(psi,Params,Transf,VDk,V);
if mod(i,10) == 0
% Change in Energy % Collect change in energy
E = this.Calculator.calculateTotalEnergy(psi,Params,Transf,VDk,V); E = this.Calculator.calculateTotalEnergy(psi,Params,Transf,VDk,V);
E = E/Norm; E = E/Norm;
Observ.EVec = [Observ.EVec E]; Observ.EVec = [Observ.EVec E];
% Chemical potential % Collect chemical potentials
Observ.mucVec = [Observ.mucVec muchem]; Observ.mucVec = [Observ.mucVec muchem];
% Normalized residuals % Collect residuals
res = this.Calculator.calculateNormalizedResiduals(psi,Params,Transf,VDk,V,muchem);
Observ.residual = [Observ.residual res]; Observ.residual = [Observ.residual res];
Observ.res_idx = Observ.res_idx + 1; Observ.res_idx = Observ.res_idx + 1;
@ -84,12 +62,12 @@ function [psi] = minimizeEnergyFunctional(this,psi,Params,Transf,VDk,V,Observ)
end end
end end
% Check if loop ended prematurely % Check if max iterations were hit without convergence
if PrematureExitFlag last_iteration_number = idx;
disp('Optimizer ended prematurely without convergence to a minimum.'); if last_iteration_number == this.MaxIterationsForGD
fprintf('Max iterations reached without convergence. Final chemical potential: %.6f, Residual: %.6f\n', muchem, residual);
else else
disp('Minimum found!'); fprintf('Converged in %d iterations. Final chemical potential: %.6f\n', last_iteration_number, muchem);
fprintf('Number of Iterations for Convergence: %d\n\n', i);
end end
% Change in Energy % Change in Energy
@ -131,42 +109,4 @@ function J = compute_gradient(psi, Params, Transf, VDk, V)
J = H(psi); J = H(psi);
end
% Line Search (Step Size Optimization)
function alpha = optimize_step_size(f, X, S, Params, Transf, VDk, V)
alpha = 1; % Initial step size
rho = 0.5; % Step size reduction factor
c = 1E-4; % Armijo condition constant
max_iter = 100; % Max iterations for backtracking
tol = 1E-4; % Tolerance for stopping
grad = compute_gradient(X, Params, Transf, VDk, V); % Compute gradient once
f_X = f(X); % Evaluate f(X) once
for k = 1:max_iter
% Evaluate Armijo condition with precomputed f(X) and grad
if f(X + alpha * S) <= f_X + c * alpha * (S(:)' * grad(:))
break;
else
alpha = rho * alpha; % Reduce the step size
end
% Early stopping if step size becomes too small
if alpha < tol
break;
end
end
end
% Update Search Direction
function S_new = update_search_direction(S, J_new, J_old)
% (Fletcher-Reeves method)
% beta = (norm(J_new(:))^2) / (norm(J_old(:))^2);
% S_new = -J_new + beta * S;
% (Polak-Ribiere method)
beta = max(0, (J_new(:)' * (J_new(:) - J_old(:))) / (norm(J_old(:))^2));
S_new = -J_new + beta * S;
end end