summaryrefslogtreecommitdiff
path: root/log-fourier_integrator.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'log-fourier_integrator.cpp')
-rw-r--r--log-fourier_integrator.cpp183
1 files changed, 120 insertions, 63 deletions
diff --git a/log-fourier_integrator.cpp b/log-fourier_integrator.cpp
index 177db46..4cd18ee 100644
--- a/log-fourier_integrator.cpp
+++ b/log-fourier_integrator.cpp
@@ -1,25 +1,31 @@
-#include "fourier.hpp"
+#include "log-fourier.hpp"
#include <getopt.h>
#include <iostream>
int main(int argc, char* argv[]) {
+ /* Model parameters */
unsigned p = 2;
unsigned s = 2;
Real λ = 0.5;
Real τ₀ = 0;
+ /* Log-Fourier parameters */
unsigned log2n = 8;
Real Δτ = 0.1;
Real k = 0.1;
- Real ε = 1e-16;
- Real γ = 1;
+ /* Iteration parameters */
+ Real ε = 1e-14;
+ Real γ₀ = 1;
+ Real β₀ = 0;
Real βₘₐₓ = 0.7;
Real Δβ = 0.01;
+ bool loadData = false;
+ unsigned stepsToRespond = 1000;
int opt;
- while ((opt = getopt(argc, argv, "p:s:2:T:t:b:d:g:k:D:")) != -1) {
+ while ((opt = getopt(argc, argv, "p:s:2:T:t:b:d:g:k:D:e:0:lS:")) != -1) {
switch (opt) {
case 'p':
p = atoi(optarg);
@@ -40,7 +46,7 @@ int main(int argc, char* argv[]) {
Δβ = atof(optarg);
break;
case 'g':
- γ = atof(optarg);
+ γ₀ = atof(optarg);
break;
case 'k':
k = atof(optarg);
@@ -48,6 +54,18 @@ int main(int argc, char* argv[]) {
case 'D':
Δτ = atof(optarg);
break;
+ case 'e':
+ ε = atof(optarg);
+ break;
+ case '0':
+ β₀ = atof(optarg);
+ break;
+ case 'l':
+ loadData = true;
+ break;
+ case 'S':
+ stepsToRespond = atoi(optarg);
+ break;
default:
exit(1);
}
@@ -58,78 +76,117 @@ int main(int argc, char* argv[]) {
LogarithmicFourierTransform fft(N, k, Δτ, 4);
Real Γ₀ = 1.0;
- Real μ = Γ₀;
+ Real μₜ₋₁ = Γ₀;
if (τ₀ > 0) {
- μ = (sqrt(1+4*Γ₀*τ₀)-1)/(2*τ₀);
+ μₜ₋₁ = (sqrt(1+4*Γ₀*τ₀)-1)/(2*τ₀);
}
- std::vector<Real> C(N);
- std::vector<Real> R(N);
- std::vector<Complex> Ct(N);
- std::vector<Complex> Rt(N);
+ std::vector<Real> Cₜ₋₁(N);
+ std::vector<Real> Rₜ₋₁(N);
+ std::vector<Complex> Ĉₜ₋₁(N);
+ std::vector<Complex> Ȓₜ₋₁(N);
- // start from the exact solution for β = 0
- for (unsigned n = 0; n < N; n++) {
- if (τ₀ > 0) {
- C[n] = Γ₀ * (exp(-μ * fft.t(n)) - μ * τ₀ * exp(-fft.t(n) / τ₀)) / (μ - pow(μ, 3) * pow(τ₀, 2));
- } else {
- C[n] = Γ₀ * exp(-μ * fft.t(n)) / μ;
+ if (!loadData) {
+ /* Start from the exact solution for β = 0 */
+ for (unsigned n = 0; n < N; n++) {
+ if (τ₀ > 0) {
+ if (τ₀ == 2) {
+ Cₜ₋₁[n] = Γ₀ * exp(-fft.t(n) / 2) * (1 + fft.t(n) / 2);
+ } else {
+ Cₜ₋₁[n] = Γ₀ * (exp(-μₜ₋₁ * fft.t(n)) - μₜ₋₁ * τ₀ * exp(-fft.t(n) / τ₀)) / (μₜ₋₁ - pow(μₜ₋₁, 3) * pow(τ₀, 2));
+ }
+ } else {
+ Cₜ₋₁[n] = Γ₀ * exp(-μₜ₋₁ * fft.t(n)) / μₜ₋₁;
+ }
+ Rₜ₋₁[n] = exp(-μₜ₋₁ * fft.t(n));
+
+ Ĉₜ₋₁[n] = 2 * Γ₀ / (pow(μₜ₋₁, 2) + pow(fft.ν(n), 2)) / (1 + pow(τ₀ * fft.ν(n), 2));
+ Ȓₜ₋₁[n] = 1.0 / (μₜ₋₁ + 1i * fft.ν(n));
}
- R[n] = exp(-μ * fft.t(n));
-
- Ct[n] = 2 * Γ₀ / (pow(μ, 2) + pow(fft.ν(n), 2)) / (1 + pow(τ₀ * fft.ν(n), 2));
- Rt[n] = 1.0 / (μ + 1i * fft.ν(n));
+ } else {
+ logFourierLoad(Cₜ₋₁, Rₜ₋₁, Ĉₜ₋₁, Ȓₜ₋₁, p, s, λ, τ₀, β₀, log2n, Δτ, k);
+ μₜ₋₁ = estimateZ(fft, Cₜ₋₁, Ĉₜ₋₁, Rₜ₋₁, Ȓₜ₋₁, p, s, λ, τ₀, β₀);
}
- Real β = 0;
+ std::vector<Real> Cₜ = Cₜ₋₁;
+ std::vector<Real> Rₜ = Rₜ₋₁;
+ std::vector<Complex> Ĉₜ = Ĉₜ₋₁;
+ std::vector<Complex> Ȓₜ = Ȓₜ₋₁;
+ Real μₜ = μₜ₋₁;
+
+ Real β = β₀ + Δβ;
while (β < βₘₐₓ) {
- Real ΔC = 100;
- while (ΔC > ε) {
- std::vector<Real> RddfC(N);
- std::vector<Real> dfC(N);
- for (unsigned n = 0; n < N; n++) {
- RddfC[n] = R[n] * ddf(λ, p, s, C[n]);
- dfC[n] = df(λ, p, s, C[n]);
+ Real γ = γ₀;
+ Real ΔCmin = 1000;
+ Real ΔCₜ = 100;
+ unsigned stepsUp = 0;
+ while (ΔCₜ > ε) {
+ auto [RddfCt, dfCt] = RddfCtdfCt(fft, Cₜ, Rₜ, p, s, λ);
+
+ std::vector<Complex> Ĉₜ₊₁(N);
+ std::vector<Complex> Ȓₜ₊₁(N);
+ for (unsigned n = 0; n < N; n++) {
+ Ȓₜ₊₁[n] = (1.0 + pow(β, 2) * RddfCt[n] * Ȓₜ[n]) / (μₜ + 1i * fft.ν(n));
+ Ĉₜ₊₁[n] = (2 * Γ₀ * std::conj(Ȓₜ[n]) / (1 + pow(τ₀ * fft.ν(n), 2)) + pow(β, 2) * (RddfCt[n] * Ĉₜ[n] + dfCt[n] * std::conj(Ȓₜ[n]))) / (μₜ + 1i * fft.ν(n));
+ }
+ std::vector<Real> Rₜ₊₁ = fft.inverse(Ȓₜ₊₁);
+ std::vector<Real> Cₜ₊₁ = fft.inverse(Ĉₜ₊₁);
+
+ μₜ *= pow(tanh(Cₜ₊₁[0]-1)+1, 0.5);
+
+ ΔCₜ = 0;
+ for (unsigned i = 0; i < N; i++) {
+ ΔCₜ += std::norm(Cₜ[i] - Cₜ₊₁[i]);
+ ΔCₜ += std::norm(Rₜ[i] - Rₜ₊₁[i]);
+ }
+ ΔCₜ = sqrt(ΔCₜ) / (2*N);
+
+ if (ΔCₜ < 0.9 * ΔCmin) {
+ ΔCmin = ΔCₜ;
+ stepsUp = 0;
+ } else {
+ stepsUp++;
+ }
+
+ if (stepsUp > stepsToRespond) {
+ γ = std::max(γ/2, 1e-4);
+ stepsUp = 0;
+ ΔCmin = ΔCₜ;
+ }
+
+ for (unsigned i = 0; i < N; i++) {
+ Cₜ[i] += γ * (Cₜ₊₁[i] - Cₜ[i]);
+ Rₜ[i] += γ * (Rₜ₊₁[i] - Rₜ[i]);
+ Ĉₜ[i] += γ * (Ĉₜ₊₁[i] - Ĉₜ[i]);
+ Ȓₜ[i] += γ * (Ȓₜ₊₁[i] - Ȓₜ[i]);
+ }
+
+ std::cerr << "\x1b[2K" << "\r";
+ std::cerr << β << " " << μₜ << " " << ΔCₜ << " " << γ << " " << Cₜ[0];
}
- std::vector<Complex> RddfCt = fft.fourier(RddfC, false);
- std::vector<Complex> dfCt = fft.fourier(dfC, true);
-
- std::vector<Complex> Rtnew(N);
- std::vector<Complex> Ctnew(N);
- for (unsigned n = 0; n < N; n++) {
- Rtnew[n] = (1.0 + pow(β, 2) * RddfCt[n] * Rt[n]) / (μ + 1i * fft.ν(n));
- Ctnew[n] = (2 * Γ₀ * std::conj(Rt[n]) / (1 + pow(τ₀ * fft.ν(n), 2)) + pow(β, 2) * (RddfCt[n] * Ct[n] + dfCt[n] * std::conj(Rt[n]))) / (μ + 1i * fft.ν(n));
- }
+ if (std::isnan(Cₜ[0])) {
+ γ₀ /= 2;
+ Cₜ = Cₜ₋₁;
+ Rₜ = Rₜ₋₁;
+ Ĉₜ = Ĉₜ₋₁;
+ Ȓₜ = Ȓₜ₋₁;
+ μₜ = μₜ₋₁;
+ } else {
+ Real E = energy(fft, Cₜ, Rₜ, p, s, λ, β);
- std::vector<Real> Cnew = fft.inverse(Ctnew);
- std::vector<Real> Rnew = fft.inverse(Rtnew);
+ std::cerr << "\x1b[2K" << "\r";
+ std::cerr << β << " " << μₜ << " " << Ĉₜ[0].real() << " " << E << " " << γ << std::endl;
- ΔC = 0;
- for (unsigned i = 0; i < N; i++) {
- ΔC += std::norm(Ct[i] - Ctnew[i]);
- ΔC += std::norm(Rt[i] - Rtnew[i]);
- }
- ΔC = sqrt(ΔC) / (2*N);
+ logFourierSave(Cₜ, Rₜ, Ĉₜ, Ȓₜ, p, s, λ, τ₀, β, log2n, Δτ, k);
- for (unsigned i = 0; i < N; i++) {
- C[i] += γ * (Cnew[i] - C[i]);
- R[i] += γ * (Rnew[i] - R[i]);
- Ct[i] += γ * (Ctnew[i] - Ct[i]);
- Rt[i] += γ * (Rtnew[i] - Rt[i]);
+ β += Δβ;
+ Cₜ₋₁ = Cₜ;
+ Rₜ₋₁ = Rₜ;
+ Ĉₜ₋₁ = Ĉₜ;
+ Ȓₜ₋₁ = Ȓₜ;
+ μₜ₋₁ = μₜ;
}
-
- μ *= C[0];
-
-// std::cerr << ΔC << std::endl;
- }
-
- std::cerr << β << " " << μ << " " << Ct[0].real() << std::endl;
- β += Δβ;
- }
-
- for (unsigned i = 0; i < N; i++) {
- std::cout << fft.t(i) << " " << Rt[i].imag() << std::endl;
}
return 0;