vcbferreira/NuFI_deal.ii
1
0
Fork 0
mirror of https://codeberg.org/vcbferreira/NuFI_deal.ii synced 2026-08-12 14:33:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

corrected saving and eval of fields over time

Browse Source
This commit is contained in:
Vasco C. B. Ferreira
2026-06-26 11:40:10 +02:00
parent 26d0637987
commit 006bd19fe2
10 changed files with 373 additions and 403 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libnufi_lib.a
BIN
View File
Binary file not shown.
nufi/fields.h
+94 -84
View File
@@ -9,52 +9,54 @@
using namespace dealii; using namespace dealii;
inline std::vector<int> Indices_of_points(const std::vector<double> &points, double x_min, double x_max, double dx, int grid_type=0) // inline std::vector<int> Indices_of_points(const std::vector<double> &points,
{ // double x_min, double x_max, double dx, int grid_type=0)
// grid type: // {
// 0 => uniform // // grid type:
// 1 => non uniform (TODO) // // 0 => uniform
// // 1 => non uniform (TODO)
if (dx <= 0.0) { //
throw std::invalid_argument("dx must be positive"); // if (dx <= 0.0) {
} // throw std::invalid_argument("dx must be positive");
if (x_max <= x_min) { // }
throw std::invalid_argument("x_max must be > x_min"); // if (x_max <= x_min) {
} // throw std::invalid_argument("x_max must be > x_min");
// }
std::vector<int> indices; //
indices.reserve(points.size()); // std::vector<int> indices;
// indices.reserve(points.size());
switch (grid_type) { //
case 0: // switch (grid_type) {
{ // case 0:
const double L = x_max - x_min; // {
const int N = std::floor(L/dx); // const double L = x_max - x_min;
// const int N = std::floor(L/dx);
//
for (double x : points) //GPT loop, to check //
{ // for (double x : points) //GPT loop, to check
x-= x_min; // {
x = x - L * std::floor(x/L); // x-= x_min;
// x = x - L * std::floor(x/L);
int i = static_cast<int>(std::floor(x / dx)); //
// int i = static_cast<int>(std::floor(x / dx));
// safety: handle rare edge case due to floating precision //
if (i == N) i = 0; // // safety: handle rare edge case due to floating precision
// if (i == N) i = 0;
indices.push_back(i); //
} // indices.push_back(i);
} // }
case 1: // }
{ // case 1:
throw std::invalid_argument("Case for non uniform grid is not completed"); // {
} // throw std::invalid_argument("Case for non uniform grid is not
default: // completed");
throw std::invalid_argument("Invalid grid_type argument"); // }
// default:
} // throw std::invalid_argument("Invalid grid_type argument");
return indices; //
} // }
// return indices;
// }
inline double f0(const double x, const double v, inline double f0(const double x, const double v,
const double eps = Parameters::EPS, const double eps = Parameters::EPS,
@@ -81,11 +83,18 @@ inline double compute_rho(const double x,
return 1.0 - integral; return 1.0 - integral;
} }
double eval(double x, const PoissonProblem<1> &poisson) noexcept { inline double eval(double x, const PoissonProblem<1> &poisson,
return poisson.evaluate_potential(Point<1>(x)); const Vector<double> &solution) noexcept {
x -= Parameters::X_DOMAIN_LEFT;
x = x - Parameters::LX * std::floor(x * Parameters::LX_INV);
return eval_point<1>(poisson.get_mapping(), poisson.get_dof_handler(),
solution, Point<1>(x));
} }
inline double integral_space_vector(const PoissonProblem<1> &poisson, inline double integral_space_vector(const PoissonProblem<1> &poisson,
const Vector<double> &solution,
double dx = Parameters::PLOT_DX, double dx = Parameters::PLOT_DX,
size_t Nx = Parameters::PLOT_NX) { size_t Nx = Parameters::PLOT_NX) {
double integral = 0.0; double integral = 0.0;
@@ -93,12 +102,13 @@ inline double integral_space_vector(const PoissonProblem<1> &poisson,
#pragma omp parallel for reduction(+ : integral) #pragma omp parallel for reduction(+ : integral)
for (size_t i = 0; i < Nx; ++i) { for (size_t i = 0; i < Nx; ++i) {
double x = xmin + i * dx; double x = xmin + i * dx;
integral += eval(x, poisson); integral += eval(x, poisson, solution);
} }
return integral * dx; return integral * dx;
}; };
inline double integral_space_vector_squared(const PoissonProblem<1> &poisson, inline double integral_space_vector_squared(const PoissonProblem<1> &poisson,
const Vector<double> &solution,
double dx = Parameters::PLOT_DX, double dx = Parameters::PLOT_DX,
size_t Nx = Parameters::PLOT_NX) { size_t Nx = Parameters::PLOT_NX) {
double integral = 0.0; double integral = 0.0;
@@ -106,46 +116,46 @@ inline double integral_space_vector_squared(const PoissonProblem<1> &poisson,
#pragma omp parallel for reduction(+ : integral) #pragma omp parallel for reduction(+ : integral)
for (size_t i = 0; i < Nx; ++i) { for (size_t i = 0; i < Nx; ++i) {
double x = xmin + i * dx; double x = xmin + i * dx;
double val = eval(x, poisson); double val = eval(x, poisson, solution);
integral += val * val; integral += val * val;
} }
return integral * dx; return integral * dx;
}; };
class Gradient { // class Gradient {
public: // public:
Gradient(double xmin, double xmax, unsigned int Nx) // Gradient(double xmin, double xmax, unsigned int Nx)
: xmin_(xmin), xmax_(xmax), Nx_(Nx) { // : xmin_(xmin), xmax_(xmax), Nx_(Nx) {
if (xmax_ <= xmin_) { // if (xmax_ <= xmin_) {
throw std::invalid_argument("xmax must be greater than xmin"); // throw std::invalid_argument("xmax must be greater than xmin");
} // }
} // }
//
std::vector<double> compute(const std::vector<double> &values) const { // std::vector<double> compute(const std::vector<double> &values) const {
size_t n = values.size(); // size_t n = values.size();
if (n < 2) { // if (n < 2) {
throw std::invalid_argument("Need at least 2 points"); // throw std::invalid_argument("Need at least 2 points");
} // }
//
std::vector<double> grad(n); // std::vector<double> grad(n);
//
double dx = (xmax_ - xmin_) / (n - 1); // double dx = (xmax_ - xmin_) / (n - 1);
// periodic boundaries // // periodic boundaries
grad[0] = -(values[1] - values[n - 1]) / (2.0 * dx); // grad[0] = -(values[1] - values[n - 1]) / (2.0 * dx);
grad[n - 1] = -(values[0] - values[n - 2]) / (2.0 * dx); // grad[n - 1] = -(values[0] - values[n - 2]) / (2.0 * dx);
//
for (size_t i = 1; i < n - 1; ++i) { // for (size_t i = 1; i < n - 1; ++i) {
grad[i] = -(values[i + 1] - values[i - 1]) / (2.0 * dx); // grad[i] = -(values[i + 1] - values[i - 1]) / (2.0 * dx);
} // }
//
return grad; // return grad;
} // }
//
private: // private:
double xmin_; // double xmin_;
double xmax_; // double xmax_;
[[maybe_unused]] unsigned int Nx_; // [[maybe_unused]] unsigned int Nx_;
}; // };
template <int dim> template <int dim>
class ChargeDensity : public Function<dim> // only uses f0 class ChargeDensity : public Function<dim> // only uses f0
nufi/nufi_solver.h
+31 -31
View File
@@ -2,32 +2,35 @@
#define NUFI_SOLVER_H #define NUFI_SOLVER_H
#include <boost/qvm/mat_access.hpp> #include <boost/qvm/mat_access.hpp>
#include <vector>
#include <cmath> #include <cmath>
#include <deal.II/base/point.h> #include <deal.II/base/point.h>
#include <deal.II/base/tensor.h> #include <deal.II/base/tensor.h>
#include <deal.II/numerics/fe_field_function.h> #include <deal.II/numerics/fe_field_function.h>
#include <vector>
#include "nufi/fields.h" //dont remove
#include "nufi/parameters.h" #include "nufi/parameters.h"
#include "nufi/poisson_problem.h" #include "nufi/poisson_problem.h"
#include "nufi/fields.h" //dont remove
using namespace dealii; using namespace dealii;
class NuFISolver class NuFISolver {
{
public: public:
NuFISolver(); NuFISolver();
void run(); void run();
double eval_rho(unsigned int n, double x, const PoissonProblem<1> &poisson, unsigned int Nv = Parameters::NV) const; double eval_rho(unsigned int n, double x, const PoissonProblem<1> &poisson,
double eval_ftilda(unsigned int n, double x, double u, const PoissonProblem<1> &poisson) const; const std::vector<Vector<double>> &phi_history,
double eval_f(unsigned int n, double x, double u, const PoissonProblem<1> &poisson) const; unsigned int Nv = Parameters::NV) const;
double eval_ftilda(unsigned int n, double x, double u,
const PoissonProblem<1> &poisson,
const std::vector<Vector<double>> &phi_history) const;
double eval_f(unsigned int n, double x, double u,
const PoissonProblem<1> &poisson,
const std::vector<Vector<double>> &phi_history) const;
private: private:
unsigned int Nt = std::floor(Parameters::TMAX / Parameters::DT);
unsigned int Nt = std::floor(Parameters::TMAX/Parameters::DT);
unsigned int Nx = Parameters::CALC_NX; unsigned int Nx = Parameters::CALC_NX;
double Lx = Parameters::LX; double Lx = Parameters::LX;
@@ -40,36 +43,33 @@ private:
unsigned int order; unsigned int order;
PoissonProblem<1> poisson; PoissonProblem<1> poisson;
}; };
template<unsigned int dim> template <unsigned int dim> class ChargeDensity_NuFI : public Function<dim> {
class ChargeDensity_NuFI : public Function<dim> public:
{ ChargeDensity_NuFI(const double *rho_values, unsigned int Nx)
public:
ChargeDensity_NuFI(const double *rho_values, unsigned int Nx)
: Function<dim>(), rho(rho_values), Nx(Nx) {} : Function<dim>(), rho(rho_values), Nx(Nx) {}
virtual double value(const Point<dim> &p, virtual double
[[maybe_unused]] const unsigned int component = 0) const override value(const Point<dim> &p,
{ [[maybe_unused]] const unsigned int component = 0) const override {
const double x = p[0]; const double x = p[0];
// Map x -> grid index // Map x -> grid index
const double L = Parameters::LX; const double L = Parameters::LX;
const double dx = L / (Nx-1); const double dx = L / (Nx - 1);
int i = static_cast<int>(std::floor((x - Parameters::X_DOMAIN_LEFT) / dx)); int i = static_cast<int>(std::floor((x - Parameters::X_DOMAIN_LEFT) / dx));
// periodic wrap // periodic wrap
i = (i % Nx + Nx) % Nx; i = (i % Nx + Nx) % Nx;
return rho[i]; return rho[i];
} }
private: private:
const double *rho; const double *rho;
const unsigned int Nx; const unsigned int Nx;
}; };
#endif #endif
nufi/parameters.h
+28 -29
View File
@@ -4,42 +4,41 @@
#include <cmath> #include <cmath>
#include <cstdlib> #include <cstdlib>
namespace Parameters namespace Parameters {
{ constexpr unsigned int DIMENSION = 1;
constexpr unsigned int DIMENSION = 1;
constexpr double X_DOMAIN_LEFT = 0.0; constexpr double X_DOMAIN_LEFT = 0.0;
constexpr double X_DOMAIN_RIGHT = 4*M_PI; constexpr double X_DOMAIN_RIGHT = 4 * M_PI;
constexpr double LX = std::abs(X_DOMAIN_RIGHT- X_DOMAIN_LEFT); constexpr double LX = std::abs(X_DOMAIN_RIGHT - X_DOMAIN_LEFT);
constexpr double LX_INV = 1/LX; constexpr double LX_INV = 1 / LX;
constexpr size_t CALC_NX = 256; constexpr size_t CALC_NX = 128;
constexpr double CALC_DX = LX/CALC_NX; constexpr double CALC_DX = LX / CALC_NX;
constexpr double V_DOMAIN_LEFT = -10.; constexpr double V_DOMAIN_LEFT = -10.;
constexpr double V_DOMAIN_RIGHT = 10.; constexpr double V_DOMAIN_RIGHT = 10.;
constexpr unsigned int NV = 256; constexpr unsigned int NV = 128;
constexpr double DV = std::abs(V_DOMAIN_RIGHT - V_DOMAIN_LEFT)/NV; constexpr double DV = std::abs(V_DOMAIN_RIGHT - V_DOMAIN_LEFT) / NV;
// deal.ii options // deal.ii options
constexpr unsigned int GLOBAL_REFINEMENT = 8; constexpr unsigned int GLOBAL_REFINEMENT = 6;
constexpr unsigned int FE_DEGREE = 3; constexpr unsigned int FE_DEGREE = 2;
constexpr unsigned int CONVERGENCE_ITERATIONS = 5000; constexpr unsigned int CONVERGENCE_ITERATIONS = 5000;
constexpr double CONVERGENCE_LIMIT = 1e-8; constexpr double CONVERGENCE_LIMIT = 1e-8;
constexpr double EPS = 0.01; constexpr double EPS = 0.01;
constexpr double WAVE_NR = 0.5; constexpr double WAVE_NR = 0.5;
constexpr double F0_FACTOR = 0.39894228040143267793994; // 1/sqrt(2pi) constexpr double F0_FACTOR = 0.39894228040143267793994; // 1/sqrt(2pi)
// NUFI options // NUFI options
constexpr double DT=1./4.; constexpr double DT = 1. / 10.;
constexpr unsigned int TMAX = 50; constexpr unsigned int TMAX = 100;
//Plotting options // Plotting options
constexpr int PLOT_FREQUENCY = 20; constexpr int PLOT_FREQUENCY = 10;
constexpr size_t PLOT_NX = 256; constexpr size_t PLOT_NX = CALC_NX;
constexpr double PLOT_DX = LX/PLOT_NX; constexpr double PLOT_DX = LX / PLOT_NX;
} } // namespace Parameters
#endif #endif
nufi/poisson_problem.h
+15 -27
View File
@@ -12,6 +12,7 @@
#include <deal.II/base/tensor.h> #include <deal.II/base/tensor.h>
#include <deal.II/base/utilities.h> #include <deal.II/base/utilities.h>
#include <deal.II/fe/mapping_q.h>
#include <deal.II/lac/affine_constraints.h> #include <deal.II/lac/affine_constraints.h>
#include <deal.II/lac/dynamic_sparsity_pattern.h> #include <deal.II/lac/dynamic_sparsity_pattern.h>
#include <deal.II/lac/full_matrix.h> #include <deal.II/lac/full_matrix.h>
@@ -61,17 +62,13 @@ public:
const Vector<double> &get_solution() const { return solution; } const Vector<double> &get_solution() const { return solution; }
const DoFHandler<dim> &get_dof_handler() const { return dof_handler; } const DoFHandler<dim> &get_dof_handler() const { return dof_handler; }
const MappingQ<dim> &get_mapping() const { return mapping; }
std::vector<double> sample_electric_field(double x_min, double x_max, std::vector<double> sample_electric_field(double x_min, double x_max,
unsigned int Nx); unsigned int Nx);
std::vector<double> sample_electric_potential(double x_min, double x_max, std::vector<double> sample_electric_potential(double x_min, double x_max,
unsigned int Nx); unsigned int Nx);
double evaluate_potential(const Point<dim> &p) const
{
return fe_field_function->value(p);
}
private: private:
void create_mesh(); void create_mesh();
void setup_system(); void setup_system();
@@ -94,7 +91,7 @@ private:
MappingQ<dim> mapping; MappingQ<dim> mapping;
std::unique_ptr<Functions::FEFieldFunction<dim>> fe_field_function; // std::unique_ptr<Functions::FEFieldFunction<dim>> fe_field_function;
}; };
// Utilities // Utilities
@@ -177,8 +174,8 @@ PoissonProblem<dim>::sample_electric_potential(double x_min, double x_max,
// template <int dim> std::vector<double> eval_solution_on_points( // template <int dim> std::vector<double> eval_solution_on_points(
// const std::vector<Vector<double>> &solutions, // const std::vector<Vector<double>> &solutions,
// const unsigned int n, // const unsigned int n,
// const std::vector<Point<dim>> &points, // need to be in [x_min, x_max]. I think.... // const std::vector<Point<dim>> &points, // need to be in [x_min,
// const std::vector<unsigned int> &cell_indices, // x_max]. I think.... const std::vector<unsigned int> &cell_indices,
// const DoFHandler<dim> &dof_handler, // const DoFHandler<dim> &dof_handler,
// const MappingQ<dim> &mapping) // const MappingQ<dim> &mapping)
// { // {
@@ -219,7 +216,8 @@ PoissonProblem<dim>::sample_electric_potential(double x_min, double x_max,
// for (unsigned int id : point_ids) // for (unsigned int id : point_ids)
// cell_points.push_back(points[id]); // cell_points.push_back(points[id]);
// //
// std::vector<types::global_dof_index> indices(dof_handler.get_fe().n_dofs_per_cell()); // std::vector<types::global_dof_index>
// indices(dof_handler.get_fe().n_dofs_per_cell());
// cell->get_dof_indices(indices); // cell->get_dof_indices(indices);
// //
// for (unsigned int i=0;i<indices.size();++i) // for (unsigned int i=0;i<indices.size();++i)
@@ -240,13 +238,8 @@ PoissonProblem<dim>::sample_electric_potential(double x_min, double x_max,
template <int dim> template <int dim>
double eval_point(const Mapping<dim> &mapping, double eval_point(const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler, const DoFHandler<dim> &dof_handler,
const Vector<double> &solution, const Vector<double> &solution, const Point<dim> &point) {
const Point<dim> &point) return VectorTools::point_value<dim>(mapping, dof_handler, solution, point);
{
return VectorTools::point_value<dim>(mapping,
dof_handler,
solution,
point);
} }
// dealii Poisson // dealii Poisson
@@ -288,7 +281,7 @@ template <int dim> void PoissonProblem<dim>::setup_system() {
gauge_dof = i; gauge_dof = i;
break; break;
} }
}
Assert(gauge_dof != numbers::invalid_dof_index, Assert(gauge_dof != numbers::invalid_dof_index,
ExcMessage("No unconstrained DoF found for gauge fixing.")); ExcMessage("No unconstrained DoF found for gauge fixing."));
@@ -307,11 +300,9 @@ template <int dim> void PoissonProblem<dim>::setup_system() {
solution.reinit(dof_handler.n_dofs()); solution.reinit(dof_handler.n_dofs());
system_rhs.reinit(dof_handler.n_dofs()); system_rhs.reinit(dof_handler.n_dofs());
fe_field_function = // fe_field_function =
std::make_unique<Functions::FEFieldFunction<dim>>( // std::make_unique<Functions::FEFieldFunction<dim>>(
dof_handler, solution, mapping); // dof_handler, solution, mapping);
}
} }
/* (Mine) /* (Mine)
template <int dim> template <int dim>
@@ -393,6 +384,8 @@ void PoissonProblem<dim>::assemble_system()
// Paul's, mine's above // Paul's, mine's above
template <int dim> void PoissonProblem<dim>::assemble_system() { template <int dim> void PoissonProblem<dim>::assemble_system() {
Assert(system_matrix.m() == dof_handler.n_dofs(),
ExcMessage("Matrix not initialized correctly"));
system_matrix = 0; system_matrix = 0;
system_rhs = 0; system_rhs = 0;
@@ -446,11 +439,6 @@ template <int dim> void PoissonProblem<dim>::solve() {
// solver.solve(system_matrix, solution, system_rhs, preconditioner); // solver.solve(system_matrix, solution, system_rhs, preconditioner);
solver.solve(system_matrix, solution, system_rhs, PreconditionIdentity()); solver.solve(system_matrix, solution, system_rhs, PreconditionIdentity());
constraints.distribute(solution); constraints.distribute(solution);
fe_field_function =
std::make_unique<Functions::FEFieldFunction<dim>>(
dof_handler, solution, mapping);
} }
template <int dim> void PoissonProblem<dim>::initialize() { template <int dim> void PoissonProblem<dim>::initialize() {
nufi/save_results.h
+15 -18
View File
@@ -1,29 +1,26 @@
#ifndef SAVE_RESULTS_H #ifndef SAVE_RESULTS_H
#define SAVE_RESULTS_H #define SAVE_RESULTS_H
#include <string>
#include "nufi/nufi_solver.h" #include "nufi/nufi_solver.h"
#include "nufi/poisson_problem.h" #include "nufi/poisson_problem.h"
#include <deal.II/lac/vector.h>
#include <string>
void save_f(const NuFISolver &solver, unsigned int n,
const PoissonProblem<1> &poisson,
const std::vector<Vector<double>> &phi_history, unsigned int Nx_out,
unsigned int Nv_out, const std::string &filename);
void save_f( const NuFISolver &solver, void save_rho(const NuFISolver &solver, unsigned int n,
unsigned int n, const PoissonProblem<1> &poisson,
const PoissonProblem<1> &poisson, const std::vector<Vector<double>> &phi_history,
unsigned int Nx_out, unsigned int Nx_out, const std::string &filename);
unsigned int Nv_out,
const std::string &filename);
void save_rho(const NuFISolver &solver, void save_Efield(unsigned int n, const PoissonProblem<1> &poisson,
unsigned int n, const std::vector<Vector<double>> &phi_history,
const PoissonProblem<1> &poisson, unsigned int Nx_out, const std::string &filename);
unsigned int Nx_out,
const std::string &filename);
void save_Efield(unsigned int n, void save_space_vector(const std::vector<double> &vals,
const PoissonProblem<1> &poisson, const std::string &filename, size_t it);
unsigned int Nx_out,
const std::string &filename);
void save_space_vector(const std::vector<double>& vals, const std::string& filename, size_t it);
#endif #endif
nufi/stopwatch.h
+12 -20
View File
@@ -3,35 +3,27 @@
#include <chrono> #include <chrono>
template <typename real> template <typename real> class stopwatch {
class stopwatch
{
public: public:
void reset(); void reset();
real elapsed(); real elapsed();
private: private:
using clock = std::chrono::high_resolution_clock; using clock = std::chrono::high_resolution_clock;
clock::time_point t0 { clock::now() }; clock::time_point t0{clock::now()};
}; };
template <typename real> inline void stopwatch<real>::reset() {
template <typename real> inline t0 = clock::now();
void stopwatch<real>::reset()
{
t0 = clock::now();
} }
template <typename real> inline template <typename real> inline real stopwatch<real>::elapsed() {
real stopwatch<real>::elapsed() using seconds = std::chrono::duration<real, std::ratio<1, 1>>;
{
using seconds = std::chrono::duration<real,std::ratio<1,1>>;
auto tnow = clock::now(); auto tnow = clock::now();
auto duration = std::chrono::duration_cast<seconds>( tnow - t0 ); auto duration = std::chrono::duration_cast<seconds>(tnow - t0);
return duration.count(); return duration.count();
} }
#endif // STOPWATCH_H #endif // STOPWATCH_H
src/main.cc
+24 -33
View File
@@ -1,44 +1,35 @@
#include <iostream>
#include <filesystem> #include <filesystem>
#include <iostream>
#include <nufi/nufi_solver.h> #include <nufi/nufi_solver.h>
void clear_results_directory(const std::string &dir) void clear_results_directory(const std::string &dir) {
{ if (!std::filesystem::exists(dir) || !std::filesystem::is_directory(dir))
if (!std::filesystem::exists(dir) || !std::filesystem::is_directory(dir)) return;
return;
for (const auto &entry : std::filesystem::directory_iterator(dir)) for (const auto &entry : std::filesystem::directory_iterator(dir)) {
{ if (std::filesystem::is_regular_file(entry)) {
if (std::filesystem::is_regular_file(entry)) std::filesystem::remove(entry.path());
{ std::cout << "Deleted: " << entry.path() << '\n';
std::filesystem::remove(entry.path());
std::cout << "Deleted: " << entry.path() << '\n';
}
} }
}
} }
int main() int main() {
{ #include <omp.h>
#include <omp.h> std::cout << "Threads: " << omp_get_max_threads() << "\n";
std::cout << "Threads: " << omp_get_max_threads() << "\n"; try {
try clear_results_directory("results");
{
clear_results_directory("results");
NuFISolver solver; NuFISolver solver;
solver.run(); solver.run();
} } catch (const std::exception &exc) {
catch (const std::exception &exc) std::cerr << "\nException:\n" << exc.what() << "\n";
{ return 1;
std::cerr << "\nException:\n" << exc.what() << "\n"; } catch (...) {
return 1; std::cerr << "\nUnknown exception!\n";
} return 1;
catch (...) }
{
std::cerr << "\nUnknown exception!\n";
return 1;
}
return 0; return 0;
} }
src/nufi_solver.cc
+105 -104
View File
@@ -1,186 +1,187 @@
#include "nufi/nufi_solver.h" #include "nufi/nufi_solver.h"
#include <algorithm> #include <algorithm>
#include <boost/qvm/mat_access.hpp>
#include <cmath> #include <cmath>
#include <cstdlib> #include <cstdlib>
#include <deal.II/base/point.h> #include <deal.II/base/point.h>
#include <deal.II/base/tensor.h> #include <deal.II/base/tensor.h>
#include <deal.II/numerics/fe_field_function.h> #include <deal.II/numerics/fe_field_function.h>
#include <cstddef>
#include <iostream> #include <iostream>
#include <memory> #include <memory>
#include <ostream> #include <ostream>
#include <cstddef>
#include <vector> #include <vector>
#include "nufi/parameters.h"
#include "nufi/save_results.h"
#include "nufi/poisson_problem.h"
#include "nufi/fields.h" #include "nufi/fields.h"
#include "nufi/parameters.h"
#include "nufi/poisson_problem.h"
#include "nufi/save_results.h"
#include "nufi/stopwatch.h" #include "nufi/stopwatch.h"
using namespace dealii; using namespace dealii;
double NuFISolver::eval_ftilda(unsigned int n, double
double x, NuFISolver::eval_ftilda(unsigned int n, double x, double u,
double u, const PoissonProblem<1> &poisson,
const PoissonProblem<1> &poisson) const const std::vector<Vector<double>> &phi_history) const {
{ if (n == 0)
if ( n == 0 ) return f0(x,u); return f0(x, u);
double Ex; double Ex;
// We omit the initial half-step. // We omit the initial half-step.
while ( --n ) while (--n) {
{ x = x - Parameters::DT * u;
x = x - Parameters::DT *u; Ex = -eval(x, poisson, phi_history[n]);
Ex = -eval(x, poisson); u = u + Parameters::DT * Ex;
u = u + Parameters::DT *Ex;
} }
// The final half-step. // The final half-step.
x -= Parameters::DT*u; x = x - Parameters::DT * u;
Ex = -eval(x, poisson); Ex = -eval(x, poisson, phi_history[n]);
u += 0.5*Parameters::DT*Ex; u += 0.5 * Parameters::DT * Ex;
return f0(x,u); return f0(x, u);
} }
double NuFISolver::eval_f(unsigned int n, double
double x, NuFISolver::eval_f(unsigned int n, double x, double u,
double u, const PoissonProblem<1> &poisson,
const PoissonProblem<1> &poisson) const const std::vector<Vector<double>> &phi_history) const {
{ if (n == 0)
if ( n == 0 ) return f0(x,u); return f0(x, u);
double Ex; double Ex;
// Initial half-step. // Initial half-step.
Ex = -eval(x, poisson); Ex = -eval(x, poisson, phi_history[n]);
u += 0.5*Parameters::DT * Ex; u += 0.5 * Parameters::DT * Ex;
while ( --n ) while (--n) {
{ x = x - Parameters::DT * u;
x = x - Parameters::DT *u; Ex = -eval(x, poisson, phi_history[n]);
Ex = -eval(x, poisson); u = u + Parameters::DT * Ex;
u = u + Parameters::DT *Ex;
} }
// The final half-step. // The final half-step.
x -= Parameters::DT*u; x = x - Parameters::DT * u;
Ex = -eval(x, poisson); Ex = -eval(x, poisson, phi_history[n]);
u += 0.5*Parameters::DT*Ex; u += 0.5 * Parameters::DT * Ex;
return f0(x,u); return f0(x, u);
} }
double NuFISolver::eval_rho(const unsigned int n, double NuFISolver::eval_rho(const unsigned int n, const double x,
const double x, const PoissonProblem<1> &poisson,
const PoissonProblem<1> &poisson, const std::vector<Vector<double>> &phi_history,
const unsigned int Nv) const const unsigned int Nv) const {
{ const double dv =
const double dv = (Parameters::V_DOMAIN_RIGHT - Parameters::V_DOMAIN_LEFT) / Nv; (Parameters::V_DOMAIN_RIGHT - Parameters::V_DOMAIN_LEFT) / Nv;
const double v_min = Parameters::V_DOMAIN_LEFT; const double v_min = Parameters::V_DOMAIN_LEFT;
double integral = 0.0; double integral = 0.0;
#pragma omp parallel for reduction (+ : integral) if (n == 0) {
for (unsigned int i = 0; i < Nv; ++i) for (unsigned int i = 0; i < Nv; ++i)
integral += eval_ftilda(n, x, v_min + i * dv, poisson); integral += f0(x, v_min + i * dv);
} else {
return 1.0 - integral*dv; #pragma omp parallel for reduction(+ : integral)
for (unsigned int i = 0; i < Nv; ++i)
integral += eval_ftilda(n, x, v_min + i * dv, poisson, phi_history);
}
return 1.0 - integral * dv;
} }
void NuFISolver::run() void NuFISolver::run() {
{
std::cout << "Building E_sline\n\n"; std::cout << "Building E_sline\n\n";
using std::abs; using std::abs;
using std::max; using std::max;
std::unique_ptr<double,decltype(std::free)*> rho { reinterpret_cast<double*>(std::aligned_alloc(64,sizeof(double)*Nx)), std::free }; std::unique_ptr<double, decltype(std::free) *> rho{
reinterpret_cast<double *>(std::aligned_alloc(64, sizeof(double) * Nx)),
std::free};
std::vector<double> int_E_squared; std::vector<double> int_E_squared;
int_E_squared.reserve(Nt); int_E_squared.reserve(Nt);
if ( rho == nullptr ) throw std::bad_alloc {}; std::vector<Vector<double>> phi_history;
Gradient grad(x_min, x_max, Nx); if (rho == nullptr)
throw std::bad_alloc{};
double total_time = 0; double total_time = 0;
std::ofstream time_file("results/simulation_time.txt");
for (unsigned int it = 0; it < Nt; ++it) for (unsigned int it = 0; it < Nt; ++it) {
{ stopwatch<double> timer;
stopwatch<double> timer;
double time_elapsed_before = timer.elapsed(); double time_elapsed_before = timer.elapsed();
std::cout << "Timestep " << it << " / " << Nt << " (simulation time = "<< it*Parameters::DT << ")"<< std::endl; std::cout << "Timestep " << it << " / " << Nt
<< " (simulation time = " << it * Parameters::DT << ")"
<< std::endl;
// compute rho // compute rho
double dx = Parameters::CALC_DX; double dx = Parameters::CALC_DX;
#pragma omp parallel for #pragma omp parallel for
for(size_t i = 0; i<Nx; i++) for (size_t i = 0; i < Nx; i++) {
{ double x = Parameters::X_DOMAIN_LEFT + i * dx;
double x = Parameters::X_DOMAIN_LEFT + i*dx; double ith_rho = eval_rho(it, x, poisson, phi_history, Parameters::NV);
double ith_rho = eval_rho(it, x, poisson, Parameters::NV);
AssertThrow(std::isfinite(ith_rho), ExcMessage("NaN detected in rho")); AssertThrow(std::isfinite(ith_rho), ExcMessage("NaN detected in rho"));
rho.get()[i] = ith_rho; rho.get()[i] = ith_rho;
} }
poisson.set_rhs_function(std::make_unique<ChargeDensity_NuFI<1>>(rho.get(), Nx)); poisson.set_rhs_function(
poisson.solve_step(); std::make_unique<ChargeDensity_NuFI<1>>(rho.get(), Nx));
poisson.solve_step();
std::vector<double> sampled_potential = poisson.sample_electric_potential(x_min, x_max, Nx); // Solution of FE phi_history.push_back(poisson.get_solution());
// These have been tested to be equivalent std::vector<double> sampled_potential =
// //////////////////////////////////////////////// poisson.sample_electric_potential(x_min, x_max, Nx); // Solution of FE
// std::vector<double> E_vals = grad.compute(sampled_potential); // vector grad of FE solution
// save_space_vector(E_vals, "electric", it);
// std::vector<double> E_vals_deal = poisson.sample_electric_field(x_min, x_max, Nx); // FE grad of soution
// save_space_vector(E_vals_deal, "electricdeal", it);
// ////////////////////////////////////////////////
double timer_elapsed = timer.elapsed();
double step_time = timer_elapsed - time_elapsed_before;
total_time += timer_elapsed;
// interpolate and save current field std::cout << "step made in " << step_time << " seconds\n\n";
if (it % Parameters::PLOT_FREQUENCY == 0) {
std::cout << "Saving results... ";
save_f(*this, it, poisson, phi_history, Parameters::PLOT_NX,
Parameters::NV, "results/ftilda_" + std::to_string(it) + ".dat");
save_rho(*this, it, poisson, phi_history, Parameters::PLOT_NX,
"results/rho_" + std::to_string(it) + ".dat");
// save_Efield(it, coeffs.get(), 128, "results/field_" +
// std::to_string(it) + ".dat");
std::vector<double> E_x(Nx,0.0) ; std::vector<double> E_x(Nx, 0.0);
#pragma omp parallel for #pragma omp parallel for
for(size_t ix=0; ix<Nx; ++ix) for (size_t ix = 0; ix < Nx; ++ix) {
{ E_x[ix] = -eval(Parameters::X_DOMAIN_LEFT + ix * dx, poisson,
E_x[ix] = -eval(Parameters::X_DOMAIN_LEFT+ix*dx, poisson); phi_history[it]);
} }
double timer_elapsed = timer.elapsed(); save_space_vector(E_x, "field", it);
total_time += timer_elapsed;
std::cout << "step made in "<< timer_elapsed-time_elapsed_before <<" seconds\n\n"; double int_val =
if (it % Parameters::PLOT_FREQUENCY == 0) 0.5 * integral_space_vector_squared(poisson, phi_history[it]);
{ int_E_squared.push_back(int_val);
std::cout << "Saving results... "; save_space_vector(int_E_squared, "electricint", it);
save_f(*this, it, poisson, Parameters::PLOT_NX, Parameters::NV, "results/ftilda_" + std::to_string(it) + ".dat"); std::cout << "Time since start = " << total_time << "\n\n";
save_rho(*this, it, poisson, Parameters::PLOT_NX, "results/rho_" + std::to_string(it) + ".dat"); }
// save_Efield(it, coeffs.get(), 128, "results/field_" + std::to_string(it) + ".dat");
save_space_vector(E_x, "field", it);
double int_val = 0.5 * integral_space_vector_squared(poisson);
int_E_squared.push_back(int_val);
save_space_vector(int_E_squared, "electricint", it);
std::cout << "Time since start = "<< total_time<<"\n\n";
}
} }
std::cout << "NuFI simulation finished in "<< total_time <<" seconds.\n"; std::cout << "NuFI simulation finished in " << total_time << " seconds.\n";
} }
NuFISolver::NuFISolver() NuFISolver::NuFISolver() : order(Parameters::FE_DEGREE), poisson(order) {
: order(Parameters::FE_DEGREE),
poisson(order)
{
std::cout << "Initializing dealii Poisson Solver\n"; std::cout << "Initializing dealii Poisson Solver\n";
poisson.initialize(); poisson.initialize();
} }
src/save_results.cc
+44 -52
View File
@@ -1,22 +1,18 @@
#include "nufi/save_results.h" #include "nufi/save_results.h"
#include "nufi/fields.h"
#include "nufi/nufi_solver.h"
#include "nufi/parameters.h" #include "nufi/parameters.h"
#include "nufi/poisson_problem.h"
#include <fstream> #include <fstream>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <vector> #include <vector>
#include "nufi/nufi_solver.h"
#include "nufi/poisson_problem.h"
#include "nufi/fields.h"
void save_f(const NuFISolver &solver, unsigned int n,
void save_f( const NuFISolver &solver, const PoissonProblem<1> &poisson,
unsigned int n, const std::vector<Vector<double>> &phi_history, unsigned int Nx_out,
const PoissonProblem<1> &poisson, unsigned int Nv_out, const std::string &filename) {
unsigned int Nx_out,
unsigned int Nv_out,
const std::string &filename)
{
std::ofstream file(filename); std::ofstream file(filename);
double xmin = Parameters::X_DOMAIN_LEFT; double xmin = Parameters::X_DOMAIN_LEFT;
@@ -32,34 +28,30 @@ void save_f( const NuFISolver &solver,
file << xmin << " " << xmax << "\n"; file << xmin << " " << xmax << "\n";
file << vmin << " " << vmax << "\n"; file << vmin << " " << vmax << "\n";
for (unsigned int i = 0; i < Nx_out; ++i) for (unsigned int i = 0; i < Nx_out; ++i) {
{ double x = xmin + (i + 0.5) * dx;
double x = xmin + (i + 0.5)*dx;
for (unsigned int j = 0; j < Nv_out; ++j) for (unsigned int j = 0; j < Nv_out; ++j) {
{ double v = vmin + (j + 0.5) * dv;
double v = vmin + (j + 0.5)*dv;
double val = solver.eval_f(n, x, v, poisson); double val = solver.eval_f(n, x, v, poisson, phi_history);
file << val; file << val;
if (j < Nv_out - 1) if (j < Nv_out - 1)
file << " "; file << " ";
} }
file << "\n"; file << "\n";
} }
file.close(); file.close();
} }
void save_rho(const NuFISolver &solver, void save_rho(const NuFISolver &solver, unsigned int n,
unsigned int n, const PoissonProblem<1> &poisson,
const PoissonProblem<1> &poisson, const std::vector<Vector<double>> &phi_history,
unsigned int Nx_out, unsigned int Nx_out, const std::string &filename) {
const std::string &filename)
{
std::ofstream file(filename); std::ofstream file(filename);
double xmin = Parameters::X_DOMAIN_LEFT; double xmin = Parameters::X_DOMAIN_LEFT;
@@ -69,20 +61,18 @@ void save_rho(const NuFISolver &solver,
file << Nx_out << "\n"; file << Nx_out << "\n";
file << xmin << " " << xmax << "\n"; file << xmin << " " << xmax << "\n";
for (unsigned int i = 0; i < Nx_out; ++i, xmin += dx) for (unsigned int i = 0; i < Nx_out; ++i, xmin += dx) {
{ double val = solver.eval_rho(n, xmin, poisson, phi_history);
double val = solver.eval_rho(n, xmin, poisson); file << val;
file << val; file << "\n";
file << "\n";
} }
file.close(); file.close();
} }
void save_Efield([[maybe_unused]]unsigned int n, void save_Efield([[maybe_unused]] unsigned int n,
const PoissonProblem<1> &poisson, const PoissonProblem<1> &poisson,
unsigned int Nx_out, const std::vector<Vector<double>> &phi_history,
const std::string &filename) unsigned int Nx_out, const std::string &filename) {
{
std::ofstream file(filename); std::ofstream file(filename);
double xmin = Parameters::X_DOMAIN_LEFT; double xmin = Parameters::X_DOMAIN_LEFT;
@@ -94,23 +84,25 @@ void save_Efield([[maybe_unused]]unsigned int n,
file << Nx_out << "\n"; file << Nx_out << "\n";
file << xmin << " " << xmax << "\n"; file << xmin << " " << xmax << "\n";
for (unsigned int i = 0; i < Nx_out; ++i, xmin += dx) for (unsigned int i = 0; i < Nx_out; ++i, xmin += dx) {
{ double val = -eval(xmin, poisson, phi_history[n]);
double val = -eval(xmin, poisson); file << val;
file << val; file << "\n";
file << "\n";
} }
file.close(); file.close();
} }
void save_space_vector(const std::vector<double>& vals, const std::string& filename, size_t it) void save_space_vector(const std::vector<double> &vals,
{ const std::string &filename, size_t it) {
std::ofstream file("results/" + filename + "_" + std::to_string(it) + ".dat"); std::ofstream file("results/" + filename + "_" + std::to_string(it) + ".dat");
if (!file) throw std::runtime_error("failed to start file in results/"); if (!file)
throw std::runtime_error("failed to start file in results/");
file << vals.size() << "\n"; file << vals.size() << "\n";
file << Parameters::X_DOMAIN_LEFT << " " << Parameters::X_DOMAIN_RIGHT << "\n"; file << Parameters::X_DOMAIN_LEFT << " " << Parameters::X_DOMAIN_RIGHT
file << std::fixed << std::setprecision(8); << "\n";
for (double val : vals) file << val << "\n"; file << std::fixed << std::setprecision(8);
for (double val : vals)
file << val << "\n";
} }