interpolation1d

done single-threded 1d interpolations; linear, rational, cubic spline, polynomial and barycentric. Still not done test functions yet. Still missing multi-core options.
2025-09-18 20:18:27 +02:00
parent 92437e5ef1
commit 3a53b6ebf7
29 changed files with 982 additions and 15 deletions
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "utils/vector.h"
+#include "modules/grid1d.h"
+
+
+namespace fvm {
+
+	template <typename T>
+
+	struct Field1D{
+
+	    const Grid1D* grid = nullptr;   // not owning
+	    utils::Vector<T> u; 			// size = grid->N
+		                          
+		Field1D() = default;
+
+		explicit Field1D(const Grid1D& g, double init = 0.0) : grid(&g), u(g.N){
+			
+		}
+
+		void generate_vertices(){
+			vertices.resize(N_vertices);
+			vertices[0] = centers[0] - ((centers[1] - centers[0])*0.5);	
+			vertices[N_vertices-1] = centers[N_centers-1] + ((centers[N_centers-1] - centers[N_centers-2])*0.5);
+			for (uint64_t i = 1; i < N_centers; ++i){
+				vertices[i] = (centers[i-1] + centers[i])*0.5;
+			}
+		}
+
+		T dx(uint64_t i) const { check(i); return vertices(i+1) - vertices(i); }
+		T center(uint64_t i) const { check(i); return centers(i); }
+private:
+	    void check(uint64_t i) const {
+	        if (i >= N_centers) throw std::runtime_error("Grid1D: cell index out of range");
+	    }
+	};
+
+
+}
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "modules/grid1d.h"
+
+
+namespace fd1d {
+
+	// -----------------------------------------------------------------------------
+	// Second derivative (u_xx) at interior cell i, central difference
+	// Works on NON-uniform grids
+	// On uniform: (u[i-1] - 2 u[i] + u[i+1]) / dx^2
+	// -----------------------------------------------------------------------------
+	template <typename T>
+	void inplace_Build_CentralDerivative_Matrix(const fvm::Grid1D<T>& g, utils::Matrix<T>& A, utils::Vector<T>& b, const utils::Vector<T>& s, const T& c){
+
+		for (uint64_t i = 1; i < g.center_idx; ++i){
+
+			A(i,i-1) = -(c/(g.centers[i] - g.centers[i-1]));
+			A(i,i) = -((c/(g.centers[i+1] - g.centers[i])) + (c/(g.centers[i] - g.centers[i-1])));
+			A(i,i+1) = -(c/(g.centers[i+1] - g.centers[i]));
+			b[i] = -s[i]*(g.vertices[i+1] - g.vertices[i]);
+		}
+    }
+	template <typename T>
+	utils::Matrix<T> Build_CentralDerivative_Matrix(const fvm::Grid1D<T>& g, utils::Vector<T>& b, const utils::Vector<T>& s, const T& c){
+		utils::Matrix<T> A(g.center_idx+1, g.center_idx+1, T{0});
+		inplace_Build_CentralDerivative_Matrix(g, A, b, s, c);
+		return A;
+    }
+
+
+	template <typename T>
+	void inplace_BC_Dirichlet(const fvm::Grid1D<T>& g, utils::Matrix<T>& A, utils::Vector<T>& b, const utils::Vector<T>& s, const T& c){
+
+		A(0,0) = -((c/(g.centers[1] - g.centers[0])) + (c/(g.centers[0] - g.vertices[0])));
+		A(0,1) = c/(g.centers[1] - g.centers[0]);
+
+		A(g.center_idx, g.center_idx-1) = c/(g.centers[g.center_idx]-g.centers[g.center_idx-1]);
+		A(g.center_idx, g.center_idx) = -((c/(g.vertices[g.vertices_idx] - g.centers[g.center_idx])) + (c/(g.centers[g.center_idx] - g.centers[g.center_idx-1])));
+    }
+
+
+	template <typename T>
+	void inplace_BC_Neumann(const fvm::Grid1D<T>& g, utils::Matrix<T>& A, const T& c){
+
+		A(0,0) = -c/(g.centers[1]-g.centers[0]);
+		A(0,1) = c/(g.centers[1]-g.centers[0]);
+
+		A(g.center_idx, g.center_idx-1) = c/(g.centers[g.center_idx]-g.centers[g.center_idx-1]);
+		A(g.center_idx, g.center_idx) = -c/(g.centers[g.center_idx]-g.centers[g.center_idx-1]);
+    }
+
+
+
+
+
+
+}
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "utils/vector.h"
+
+
+namespace fvm {
+
+	template <typename T>
+
+	struct Grid1D{
+		uint64_t center_idx;				// max cell index
+		uint64_t vertices_idx;				// max vertice index
+		utils::Vector<T> centers;			// size N (unknowns at cell centers)
+		utils::Vector<T> vertices;			// size N+1 (face positions)
+
+		Grid1D() = default;
+
+		explicit Grid1D(const utils::Vector<T>& midpoints){
+			centers = midpoints;
+			center_idx = centers.size()-1;
+			vertices_idx = centers.size();		
+		}
+
+		void generate_vertices(T left, T right){
+			vertices.resize(vertices_idx+1);
+			vertices[0] = left;	
+			vertices[vertices_idx] = right;
+			for (uint64_t i = 1; i < center_idx+1; ++i){
+				vertices[i] = (centers[i-1] + centers[i])*0.5;
+			}
+
+		}
+
+		T dx(uint64_t i) const { check(i); return vertices[i+1] - vertices[i]; }
+		T center(uint64_t i) const { check(i); return centers[i]; }
+
+	    void check(uint64_t i) const {
+	        if (i > center_idx) throw std::runtime_error("Grid1D: cell index out of range");
+	    }
+	};
+
+
+}