main.cpp

Go to the documentation of this file.

 
#include <cmath>
#include <complex>
#include <fstream>
#include <omp.h>
#include <string>
#include <vector>
 
#include "PenningTrap.hpp"
#include "constants.hpp"
#include "utils.hpp"
 
#define PARTICLES 100
#define N 40000
 
// Particles used for testing
Particle p1(vec3{20., 0., 20.}, vec3{0., 25., 0.}); 
Particle p2(vec3{25., 25., 0.}, vec3{0., 40., 5.}); 
 
vec3 analytical_solution_particle_1(double t)
{
    double w_0 = T / CA_MASS;
    double w_z2 = (50. * V / 1000.) / (CA_MASS * 500. * 500.);
    double w_p = (w_0 + std::sqrt(w_0 * w_0 - 2. * w_z2)) / 2.;
    double w_n = (w_0 - std::sqrt(w_0 * w_0 - 2. * w_z2)) / 2.;
    double A_p = (25. + w_n * 20.) / (w_n - w_p);
    double A_n = -(25. + w_p * 20.) / (w_n - w_p);
    std::cout << A_p << "," << A_n << std::endl;
    std::complex<double> f =
        A_p * std::exp(std::complex<double>(0., -w_p * t))
        + A_n * std::exp(std::complex<double>(0., -w_n * t));
    vec3 res{std::real(f), std::imag(f), 20. * std::cos(std::sqrt(w_z2) * t)};
    return res;
}
 
void simulate_single_particle()
{
    // Initialize trap with particle 1
    PenningTrap trap(std::vector<Particle>{p1});
 
    double time = 50.; // microseconds
 
    // Simulate and write results to file
    trap.write_simulation_to_dir("output/simulate_single_particle", time, N,
                                 "rk4", false);
}
 
void simulate_two_particles()
{
    // Initialize traps with particles
    PenningTrap trap_no_interaction(std::vector<Particle>{p1, p2});
    PenningTrap trap_with_interaction(std::vector<Particle>{p1, p2});
 
    double time = 50.; // microseconds
 
    // Simulate and write results to files
    trap_no_interaction.write_simulation_to_dir(
        "output/simulate_2_particles/no_interaction", time, N, "rk4", false);
    trap_with_interaction.write_simulation_to_dir(
        "output/simulate_2_particles/with_interaction", time, N);
}
 
void simulate_single_particle_with_different_steps()
{
    double time = 50.; // microseconds
 
    std::ofstream ofile;
 
    // Calculate relative error for RK4
    std::string path = "output/relative_error/RK4/";
    mkpath(path);
#pragma omp parallel for private(ofile)
    for (int i = 0; i < 4; i++) {
        int steps = 4000 * std::pow(2, i);
        std::cout << steps << std::endl;
        double dt = time / (double)steps;
        ofile.open(path + std::to_string(steps) + "_steps.txt");
        PenningTrap trap(std::vector<Particle>{p1});
        simulation_t res = trap.simulate(time, steps, "rk4", false);
        for (int i = 0; i < steps; i++) {
            ofile << arma::norm(res.r_vecs[0][i]
                                - analytical_solution_particle_1(dt * i))
                  << '\n';
        }
        ofile.close();
    }
 
    // Calculate relative error for forward Euler
    path = "output/relative_error/euler/";
    mkpath(path);
#pragma omp parallel for private(ofile)
    for (int i = 0; i < 4; i++) {
        int steps = 4000 * std::pow(2, i);
        double dt = time / (double)steps;
        ofile.open(path + std::to_string(steps) + "_steps.txt");
        PenningTrap trap(std::vector<Particle>{p1});
        simulation_t res = trap.simulate(time, steps, "euler", false);
        for (int i = 0; i < steps; i++) {
            ofile << arma::norm(res.r_vecs[0][i]
                                - analytical_solution_particle_1(dt * i))
                  << '\n';
        }
        ofile.close();
    }
}
 
void simulate_100_particles()
{
    PenningTrap trap((unsigned)100);
 
    double time = 50.; // microseconds
 
    // trap.write_simulation_to_dir("output/simulate_100_particles", time, N,
    //"rk4", false);
    trap.simulate(time, N, "rk4", true);
}
 
void potential_resonance_wide_sweep()
{
    double time = 500.;
 
    double amplitudes[]{.1, .4, .7};
 
    double freq_start = .2;
    double freq_end = 2.5;
    double freq_increment = .02;
    size_t freq_iterations =
        (size_t)((freq_end - freq_start) / freq_increment) + 1;
 
    double res[4][freq_iterations];
 
    std::string path = "output/time_dependent_potential/";
    mkpath(path);
 
    std::ofstream ofile;
 
#pragma omp parallel for
    // Insert frequencies
    for (size_t i = 0; i < freq_iterations; i++) {
        res[0][i] = freq_start + freq_increment * i;
    }
 
#pragma omp parallel
    {
        // Each thread creates a PenningTrap instance and reuses it throughout
        // the sweep.
        PenningTrap trap((uint)100);
#pragma omp for collapse(2)
        for (size_t i = 0; i < 3; i++) {
            for (size_t j = 0; j < freq_iterations; j++) {
                // Reset particles and give new time dependent potential.
                trap.reinitialize(amplitudes[i], res[0][j]);
                res[i + 1][j] =
                    trap.fraction_of_particles_left(time, N, "rk4", false);
            }
        }
    }
 
    // Write results to file
    ofile.open(path + "wide_sweep.txt");
    for (size_t i = 0; i < freq_iterations; i++) {
        ofile << res[0][i] << ',' << res[1][i] << ',' << res[2][i] << ','
              << res[3][i] << '\n';
    }
    ofile.close();
}
 
void potential_resonance_narrow_sweep()
{
    double time = 500.;
 
    double amplitudes[]{.1, .4, .7};
 
    double freq_start = 1.1;
    double freq_end = 1.7;
    double freq_increment = .002;
    size_t freq_iterations =
        (size_t)((freq_end - freq_start) / freq_increment) + 1;
 
    double res[4][freq_iterations];
 
    std::string path = "output/time_dependent_potential/";
    mkpath(path);
 
    std::ofstream ofile;
 
#pragma omp parallel for
    // Insert frequencies
    for (size_t i = 0; i < freq_iterations; i++) {
        res[0][i] = freq_start + freq_increment * i;
    }
 
#pragma omp parallel
    {
        // Each thread creates a PenningTrap instance and reuses it throughout
        // the sweep.
        PenningTrap trap((uint)100);
#pragma omp for collapse(2)
        for (size_t i = 0; i < 3; i++) {
            for (size_t j = 0; j < freq_iterations; j++) {
                // Reset particles and give new time dependent potential.
                trap.reinitialize(amplitudes[i], res[0][j]);
                res[i + 1][j] =
                    trap.fraction_of_particles_left(time, N, "rk4", false);
            }
        }
    }
 
    // Write results to file
    ofile.open(path + "narrow_sweep.txt");
    for (size_t i = 0; i < freq_iterations; i++) {
        ofile << res[0][i] << ',' << res[1][i] << ',' << res[2][i] << ','
              << res[3][i] << '\n';
    }
    ofile.close();
}
 
void potential_resonance_narrow_sweep_interaction()
{
    double time = 500.;
 
    double amplitudes[]{.1, .4, .7};
 
    double freq_start = 1.1;
    double freq_end = 1.7;
    double freq_increment = .002;
    size_t freq_iterations =
        (size_t)((freq_end - freq_start) / freq_increment) + 1;
 
    double res[4][freq_iterations];
 
    std::string path = "output/time_dependent_potential/";
    mkpath(path);
 
    std::ofstream ofile;
 
#pragma omp parallel for
    for (size_t i = 0; i < freq_iterations; i++) {
        res[0][i] = freq_start + freq_increment * i;
    }
 
#pragma omp parallel
    {
        // Each thread creates a PenningTrap instance and reuses it throughout
        // the sweep.
        PenningTrap trap((uint)100);
#pragma omp for collapse(2)
        for (size_t i = 0; i < 3; i++) {
            for (size_t j = 0; j < freq_iterations; j++) {
                // Reset particles and give new time dependent potential.
                trap.reinitialize(amplitudes[i], res[0][j]);
                res[i + 1][j] = trap.fraction_of_particles_left(time, N);
            }
        }
    }
 
    // Write results to file
    ofile.open(path + "narrow_sweep_interactions.txt");
    for (size_t i = 0; i < freq_iterations; i++) {
        ofile << res[0][i] << ',' << res[1][i] << ',' << res[2][i] << ','
              << res[3][i] << '\n';
    }
    ofile.close();
}
 
int main()
{
    int option = 1;
    bool chosen = false;
 
    system("clear");
    std::cout << "(1) All (default)\n"
              << "(2) Simulate single particle\n"
              << "(3) simulate 2 particles\n"
              << "(4) Simulate single particle with different time steps\n"
              << "(5) Simulate 100 particles\n"
              << "(6) Potential resonance wide sweep\n"
              << "(7) Potential resonance narrow sweep without particle "
                 "interactions\n"
              << "(8) Potential resonance narrow sweep with particle "
                 "interaction\n"
              << "Select what to run: ";
    std::cin >> std::noskipws;
    do {
        if (!(std::cin >> option) || option < 1 || option > 8) {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            system("clear");
            std::cout
                << "(1) All (default)\n"
                << "(2) Simulate single particle\n"
                << "(3) simulate 2 particles\n"
                << "(4) Simulate single particle with different time steps\n"
                << "(5) Simulate 100 particles\n"
                << "(6) Potential resonance wide sweep\n"
                << "(7) Potential resonance narrow sweep without particle "
                   "interactions\n"
                << "(8) Potential resonance narrow sweep with particle "
                   "interaction\n"
                << "Not a valid option, please enter a valid number: ";
        } else {
            chosen = true;
        }
    } while (!chosen);
 
    double start, end;
 
    system("clear");
 
    start = omp_get_wtime();
    switch (option) {
    case 1:
        std::cout << "Running simulate_single_particle\n";
        simulate_single_particle();
 
        std::cout << "Running simulate_two_particles\n";
        simulate_two_particles();
 
        std::cout << "Running simulate_single_particle_with_different_steps\n";
        simulate_single_particle_with_different_steps();
 
        std::cout << "Running simulate_100_particles\n";
        simulate_100_particles();
 
        std::cout << "Running potential_resonance_wide_sweep\n";
        potential_resonance_wide_sweep();
 
        std::cout << "Running potential_resonance_narrow_sweep\n";
        potential_resonance_narrow_sweep();
 
        std::cout << "Running potential_resonance_narrow_sweep_interaction\n";
        potential_resonance_narrow_sweep_interaction();
        break;
    case 2:
        std::cout << "Running simulate_single_particle\n";
        simulate_single_particle();
        break;
    case 3:
        std::cout << "Running simulate_two_particles\n";
        simulate_two_particles();
        break;
    case 4:
        std::cout << "Running simulate_single_particle_with_different_steps\n";
        simulate_single_particle_with_different_steps();
        break;
    case 5:
        std::cout << "Running simulate_100_particles\n";
        simulate_100_particles();
        break;
    case 6:
        std::cout << "Running potential_resonance_wide_sweep\n";
        potential_resonance_wide_sweep();
        break;
    case 7:
        std::cout << "Running potential_resonance_narrow_sweep\n";
        potential_resonance_narrow_sweep();
        break;
    case 8:
        std::cout << "Running potential_resonance_narrow_sweep_interaction\n";
        potential_resonance_narrow_sweep_interaction();
        break;
    }
    end = omp_get_wtime();
 
    std::cout << "Time: " << end - start << " seconds" << std::endl;
 
    return 0;
}