moebiusband/NuSiF-Solver
2
0
Fork 2
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Incomplete 3D enhanced solver + slides

Browse Source
This commit is contained in:
Aditya Ujeniya
2023-10-12 17:46:33 +02:00
parent 86f7677f34
commit 4c374c82c7
34 changed files with 22943 additions and 19447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
PoissonSolver/2D-mpi/poisson.par
View File

@@ -8,8 +8,8 @@ name poisson
xlength 1.0 # domain size in x-direction
ylength 1.0 # domain size in y-direction
imax 200 # number of interior cells in x-direction
jmax 200 # number of interior cells in y-direction
imax 1000 # number of interior cells in x-direction
jmax 10000 # number of interior cells in y-direction
# Pressure Iteration Data:
# -----------------------

73
PoissonSolver/2D-mpi/result.csv Normal file
View File

@@ -0,0 +1,73 @@
Rank, SOR, RB
1, 1138.31, 447.94
2, 569.26, 225.46
3, 379.59, 150.36
4, 284.87, 112.45
5, 227.82, 89.36
6, 190.25, 75.91
7, 163.19, 64.62
8, 142.55, 56.34
9, 126.80, 49.90
10, 114.09, 45.32
11, 103.80, 40.71
12, 95.28, 37.55
13, 87.99, 35.60
14, 81.72, 33.19
15, 76.30, 30.71
16, 71.51, 29.01
17, 67.35, 26.94
18, 63.69, 25.98
19, 60.47, 24.49
20, 57.49, 23.21
21, 54.81, 22.22
22, 52.26, 21.01
23, 50.01, 20.81
24, 47.93, 19.83
25, 46.04, 18.94
26, 44.30, 18.01
27, 42.68, 17.71
28, 41.16, 16.93
29, 39.72, 16.33
30, 38.51, 16.10
31, 37.31, 15.27
32, 36.15, 14.86
33, 35.11, 14.31
34, 34.08, 13.76
35, 33.13, 13.50
36, 32.22, 13.41
37, 31.37, 12.86
38, 30.55, 12.65
39, 29.83, 12.04
40, 29.02, 11.88
41, 28.34, 11.45
42, 27.75, 11.33
43, 27.13, 10.96
44, 26.52, 10.69
45, 26.02, 10.43
46, 25.37, 10.24
47, 24.86, 10.07
48, 24.42, 9.76
49, 23.93, 9.85
50, 23.38, 9.44
51, 23.11, 9.33
52, 22.58, 9.01
53, 22.18, 8.95
54, 21.82, 8.78
55, 21.39, 8.56
56, 21.04, 8.45
57, 20.71, 8.30
58, 20.38, 8.10
59, 20.03, 7.99
60, 19.78, 7.77
61, 19.44, 7.64
62, 19.15, 7.55
63, 18.83, 7.46
64, 18.66, 7.29
65, 18.25, 7.19
66, 18.07, 7.09
67, 17.83, 7.02
68, 17.60, 6.90
69, 17.48, 6.84
70, 17.22, 6.78
71, 19.10, 6.74
72, 17.46, 6.83
1 Rank SOR RB
2 1 1138.31 447.94
3 2 569.26 225.46
4 3 379.59 150.36
5 4 284.87 112.45
6 5 227.82 89.36
7 6 190.25 75.91
8 7 163.19 64.62
9 8 142.55 56.34
10 9 126.80 49.90
11 10 114.09 45.32
12 11 103.80 40.71
13 12 95.28 37.55
14 13 87.99 35.60
15 14 81.72 33.19
16 15 76.30 30.71
17 16 71.51 29.01
18 17 67.35 26.94
19 18 63.69 25.98
20 19 60.47 24.49
21 20 57.49 23.21
22 21 54.81 22.22
23 22 52.26 21.01
24 23 50.01 20.81
25 24 47.93 19.83
26 25 46.04 18.94
27 26 44.30 18.01
28 27 42.68 17.71
29 28 41.16 16.93
30 29 39.72 16.33
31 30 38.51 16.10
32 31 37.31 15.27
33 32 36.15 14.86
34 33 35.11 14.31
35 34 34.08 13.76
36 35 33.13 13.50
37 36 32.22 13.41
38 37 31.37 12.86
39 38 30.55 12.65
40 39 29.83 12.04
41 40 29.02 11.88
42 41 28.34 11.45
43 42 27.75 11.33
44 43 27.13 10.96
45 44 26.52 10.69
46 45 26.02 10.43
47 46 25.37 10.24
48 47 24.86 10.07
49 48 24.42 9.76
50 49 23.93 9.85
51 50 23.38 9.44
52 51 23.11 9.33
53 52 22.58 9.01
54 53 22.18 8.95
55 54 21.82 8.78
56 55 21.39 8.56
57 56 21.04 8.45
58 57 20.71 8.30
59 58 20.38 8.10
60 59 20.03 7.99
61 60 19.78 7.77
62 61 19.44 7.64
63 62 19.15 7.55
64 63 18.83 7.46
65 64 18.66 7.29
66 65 18.25 7.19
67 66 18.07 7.09
68 67 17.83 7.02
69 68 17.60 6.90
70 69 17.48 6.84
71 70 17.22 6.78
72 71 19.10 6.74
73 72 17.46 6.83

39
PoissonSolver/2D-mpi/sample.sh Executable file
View File

@@ -0,0 +1,39 @@
#!/bin/bash -l
#SBATCH --job-name=Sim
#SBATCH --output=Sim_Fritz.o%j
#SBATCH --partition=singlenode
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=21
#SBATCH --ntasks=21
#SBATCH --time=20:00:00
#SBATCH --constraint=hwperf
#SBATCH --export=NONE
#SBATCH --cpu-freq=2400000-2400000:performance
unset SLURM_EXPORT_ENV
echo "Starting: $(date)"
export
module load python intel/2022.1.0 intelmpi/2021.7.0 itac #likwid/5.2.2
module list
cd $SLURM_SUBMIT_DIR
rm result.csv
touch result.csv
echo "Rank, SOR, RB" >> result.csv
for i in $(seq 1 1 72)
do
time="$i, "
time+="$(srun --cpu-freq=2200000-2200000:performance -n $i ./exe-ICC poisson.par 1 | grep 'Solution took' | cut -c 15-)"
time+=", "
time+="$(srun --cpu-freq=2200000-2200000:performance -n $i ./exe-ICC poisson.par 2 | grep 'Solution took' | cut -c 15-)"
time=${time//s}
echo $time >> result.csv
done

33
PoissonSolver/2D-mpi/src/main.c
View File

@@ -4,19 +4,20 @@
* Use of this source code is governed by a MIT-style
* license that can be found in the LICENSE file.
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <limits.h>
#include <float.h>
#include <limits.h>
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "parameter.h"
#include "solver.h"
#include "timing.h"
enum VARIANT { SOR = 1, RB, RBA };
int main (int argc, char** argv)
int main(int argc, char** argv)
{
int rank;
int variant = RB;
@@ -24,28 +25,30 @@ int main (int argc, char** argv)
Parameter params;
Solver solver;
double S, E;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
initParameter(&params);
if ( argc < 2 ) {
printf("Usage: %s <configFile>\n",argv[0]);
if (argc < 2) {
printf("Usage: %s <configFile>\n", argv[0]);
exit(EXIT_SUCCESS);
}
readParameter(&params, argv[1]);
if (argc == 3)
{
if (argc == 3) {
variant = atoi(argv[2]);
}
if ( rank == 0 ) {
if (rank == 0) {
printParameter(&params);
}
initSolver(&solver, &params, 2);
S = getTimeStamp();
switch (variant) {
case SOR:
printf("Plain SOR\n");
@@ -60,7 +63,13 @@ int main (int argc, char** argv)
solveRBA(&solver);
break;
}
//getResult(&solver);
// getResult(&solver);
E = getTimeStamp();
if (rank == 0) {
printf("Solution took %.2fs\n", E - S);
}
MPI_Finalize();
return EXIT_SUCCESS;

339
PoissonSolver/2D-mpi/src/solver.c
View File

@@ -4,49 +4,53 @@
* Use of this source code is governed by a MIT style
* license that can be found in the LICENSE file.
*/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include "solver.h"
#include "parameter.h"
#include "allocate.h"
#include "parameter.h"
#include "solver.h"
#define PI 3.14159265358979323846
#define P(i,j) p[(j)*(imax+2) + (i)]
#define RHS(i,j) rhs[(j)*(imax+2) + (i)]
#define PI 3.14159265358979323846
#define P(i, j) p[(j) * (imax + 2) + (i)]
#define RHS(i, j) rhs[(j) * (imax + 2) + (i)]
static int sizeOfRank(int rank, int size, int N)
{
return N/size + ((N%size>rank) ? 1 : 0);
return N / size + ((N % size > rank) ? 1 : 0);
}
static void print(Solver* solver)
{
double* p = solver->p;
int imax = solver->imax;
int imax = solver->imax;
printf("### RANK %d #######################################################\n", solver->rank);
for( int j=0; j < solver->jmaxLocal+2; j++ ) {
printf("### RANK %d #######################################################\n",
solver->rank);
for (int j = 0; j < solver->jmaxLocal + 2; j++) {
printf("%02d: ", j);
for( int i=0; i < solver->imax+2; i++ ) {
for (int i = 0; i < solver->imax + 2; i++) {
printf("%12.8f ", P(i, j));
}
printf("\n");
}
fflush( stdout );
fflush(stdout);
}
static void exchange(Solver* solver)
{
MPI_Request requests[4] = { MPI_REQUEST_NULL, MPI_REQUEST_NULL, MPI_REQUEST_NULL, MPI_REQUEST_NULL };
MPI_Request requests[4] = { MPI_REQUEST_NULL,
MPI_REQUEST_NULL,
MPI_REQUEST_NULL,
MPI_REQUEST_NULL };
/* exchange ghost cells with top neighbor */
if (solver->rank + 1 < solver->size) {
int top = solver->rank + 1;
double* src = solver->p + (solver->jmaxLocal) * (solver->imax+2) + 1;
double* dst = solver->p + (solver->jmaxLocal+1) * (solver->imax+2) + 1;
int top = solver->rank + 1;
double* src = solver->p + (solver->jmaxLocal) * (solver->imax + 2) + 1;
double* dst = solver->p + (solver->jmaxLocal + 1) * (solver->imax + 2) + 1;
MPI_Isend(src, solver->imax, MPI_DOUBLE, top, 1, MPI_COMM_WORLD, &requests[0]);
MPI_Irecv(dst, solver->imax, MPI_DOUBLE, top, 2, MPI_COMM_WORLD, &requests[1]);
@@ -54,203 +58,213 @@ static void exchange(Solver* solver)
/* exchange ghost cells with bottom neighbor */
if (solver->rank > 0) {
int bottom = solver->rank - 1;
double* src = solver->p + (solver->imax+2) + 1;
int bottom = solver->rank - 1;
double* src = solver->p + (solver->imax + 2) + 1;
double* dst = solver->p + 1;
MPI_Isend(src, solver->imax, MPI_DOUBLE, bottom, 2, MPI_COMM_WORLD, &requests[2]);
MPI_Irecv(dst, solver->imax, MPI_DOUBLE, bottom, 1, MPI_COMM_WORLD, &requests[3]);
MPI_Isend(src, solver->imax, MPI_DOUBLE, bottom, 2, MPI_COMM_WORLD, &requests[2]);
MPI_Irecv(dst, solver->imax, MPI_DOUBLE, bottom, 1, MPI_COMM_WORLD, &requests[3]);
}
MPI_Waitall(4, requests, MPI_STATUSES_IGNORE);
}
void getResult(Solver *solver)
void getResult(Solver* solver)
{
double* Pall = NULL;
int *rcvCounts, *displs;
if ( solver->rank == 0 ) {
Pall = allocate(64, (solver->imax+2) * (solver->jmax+2) * sizeof(double));
rcvCounts = (int*) malloc(solver->size * sizeof(int));
displs = (int*) malloc(solver->size * sizeof(int));
rcvCounts[0] = solver->jmaxLocal * (solver->imax+2);
displs[0] = 0;
int cursor = rcvCounts[0];
if (solver->rank == 0) {
Pall = allocate(64, (solver->imax + 2) * (solver->jmax + 2) * sizeof(double));
rcvCounts = (int*)malloc(solver->size * sizeof(int));
displs = (int*)malloc(solver->size * sizeof(int));
rcvCounts[0] = solver->jmaxLocal * (solver->imax + 2);
displs[0] = 0;
int cursor = rcvCounts[0];
for ( int i=1; i < solver->size; i++ ) {
rcvCounts[i] = sizeOfRank(i, solver->size, solver->jmax) * (solver->imax+2);
displs[i] = cursor;
for (int i = 1; i < solver->size; i++) {
rcvCounts[i] = sizeOfRank(i, solver->size, solver->jmax) * (solver->imax + 2);
displs[i] = cursor;
cursor += rcvCounts[i];
}
}
int cnt = solver->jmaxLocal*(solver->imax+2);
double* sendbuffer = solver->p + (solver->imax+2);
MPI_Gatherv(sendbuffer, cnt, MPI_DOUBLE, Pall,
rcvCounts, displs, MPI_DOUBLE, 0, MPI_COMM_WORLD);
int cnt = solver->jmaxLocal * (solver->imax + 2);
double* sendbuffer = solver->p + (solver->imax + 2);
MPI_Gatherv(sendbuffer,
cnt,
MPI_DOUBLE,
Pall,
rcvCounts,
displs,
MPI_DOUBLE,
0,
MPI_COMM_WORLD);
if ( solver->rank == 0 ) {
if (solver->rank == 0) {
writeResult(solver, Pall, "p.dat");
}
}
void initSolver(Solver *solver, Parameter *params, int problem)
void initSolver(Solver* solver, Parameter* params, int problem)
{
MPI_Comm_rank(MPI_COMM_WORLD, &(solver->rank));
MPI_Comm_size(MPI_COMM_WORLD, &(solver->size));
solver->imax = params->imax;
solver->jmax = params->jmax;
solver->imax = params->imax;
solver->jmax = params->jmax;
solver->jmaxLocal = sizeOfRank(solver->rank, solver->size, solver->jmax);
printf("RANK %d: imaxLocal : %d, jmaxLocal : %d\n", solver->rank, solver->imax, solver->jmaxLocal);
printf("RANK %d: imaxLocal : %d, jmaxLocal : %d\n",
solver->rank,
solver->imax,
solver->jmaxLocal);
solver->dx = params->xlength/params->imax;
solver->dy = params->ylength/params->jmax;
solver->ys = solver->rank * solver->jmaxLocal * solver->dy;
solver->eps = params->eps;
solver->omega = params->omg;
solver->dx = params->xlength / params->imax;
solver->dy = params->ylength / params->jmax;
solver->ys = solver->rank * solver->jmaxLocal * solver->dy;
solver->eps = params->eps;
solver->omega = params->omg;
solver->itermax = params->itermax;
int imax = solver->imax;
int jmax = solver->jmax;
int imax = solver->imax;
int jmax = solver->jmax;
int jmaxLocal = solver->jmaxLocal;
solver->p = allocate(64, (imax+2) * (jmaxLocal+2) * sizeof(double));
solver->rhs = allocate(64, (imax+2) * (jmax+2) * sizeof(double));
solver->p = allocate(64, (imax + 2) * (jmaxLocal + 2) * sizeof(double));
solver->rhs = allocate(64, (imax + 2) * (jmax + 2) * sizeof(double));
double dx = solver->dx;
double dy = solver->dy;
double* p = solver->p;
double dx = solver->dx;
double dy = solver->dy;
double* p = solver->p;
double* rhs = solver->rhs;
for( int j=0; j<jmaxLocal+2; j++ ) {
for (int j = 0; j < jmaxLocal + 2; j++) {
double y = solver->ys + j * dy;
for( int i=0; i<imax+2; i++ ) {
P(i,j) = sin(4.0*PI*i*dx)+sin(4.0*PI*y);
for (int i = 0; i < imax + 2; i++) {
P(i, j) = sin(4.0 * PI * i * dx) + sin(4.0 * PI * y);
}
}
if(problem == 2) {
for( int j=0; j<jmax+2; j++ ) {
for( int i=0; i<imax+2; i++ ) {
RHS(i,j) = sin(2.0*PI*i*dx);
if (problem == 2) {
for (int j = 0; j < jmax + 2; j++) {
for (int i = 0; i < imax + 2; i++) {
RHS(i, j) = sin(2.0 * PI * i * dx);
}
}
} else {
for( int j=0; j<jmax+2; j++ ) {
for( int i=0; i<imax+2; i++ ) {
RHS(i,j) = 0.0;
for (int j = 0; j < jmax + 2; j++) {
for (int i = 0; i < imax + 2; i++) {
RHS(i, j) = 0.0;
}
}
}
}
void debug(Solver *solver)
void debug(Solver* solver)
{
int imax = solver->imax;
int rank = solver->rank;
int imax = solver->imax;
int rank = solver->rank;
double* p = solver->p;
/* for( int j=0; j < solver->jmaxLocal+2; j++ ) { */
/* for( int i=0; i < solver->imax+2; i++ ) { */
/* P(i, j) = (double) rank; */
/* } */
/* } */
/* for( int j=0; j < solver->jmaxLocal+2; j++ ) { */
/* for( int i=0; i < solver->imax+2; i++ ) { */
/* P(i, j) = (double) rank; */
/* } */
/* } */
/* for ( int i=0; i < solver->size; i++) { */
/* if ( i == rank ) { */
/* print(solver); */
/* } */
/* MPI_Barrier(MPI_COMM_WORLD); */
/* } */
/* for ( int i=0; i < solver->size; i++) { */
/* if ( i == rank ) { */
/* print(solver); */
/* } */
/* MPI_Barrier(MPI_COMM_WORLD); */
/* } */
/* if ( rank == 0 ) { */
/* printf("##########################################################\n"); */
/* printf("## Exchange ghost layers\n"); */
/* printf("##########################################################\n"); */
/* } */
/* exchange(solver); */
/* if ( rank == 0 ) { */
/* printf("##########################################################\n"); */
/* printf("## Exchange ghost layers\n"); */
/* printf("##########################################################\n"); */
/* } */
/* exchange(solver); */
for ( int i=0; i < solver->size; i++) {
if ( i == rank ) {
print(solver);
for (int i = 0; i < solver->size; i++) {
if (i == rank) {
print(solver);
}
MPI_Barrier(MPI_COMM_WORLD);
}
}
int solve(Solver *solver)
int solve(Solver* solver)
{
double r;
int it = 0;
double res, res1;
int imax = solver->imax;
int jmax = solver->jmax;
int imax = solver->imax;
int jmax = solver->jmax;
int jmaxLocal = solver->jmaxLocal;
double eps= solver->eps;
double omega = solver->omega;
int itermax = solver->itermax;
double eps = solver->eps;
double omega = solver->omega;
int itermax = solver->itermax;
double dx2 = solver->dx * solver->dx;
double dy2 = solver->dy * solver->dy;
double idx2 = 1.0/dx2;
double idy2 = 1.0/dy2;
double factor = omega * 0.5 * (dx2*dy2) / (dx2+dy2);
double* p = solver->p;
double* rhs = solver->rhs;
double dx2 = solver->dx * solver->dx;
double dy2 = solver->dy * solver->dy;
double idx2 = 1.0 / dx2;
double idy2 = 1.0 / dy2;
double factor = omega * 0.5 * (dx2 * dy2) / (dx2 + dy2);
double* p = solver->p;
double* rhs = solver->rhs;
double epssq = eps * eps;
res = eps + 1.0;
while((res >= epssq) && (it < itermax)) {
while ((res >= epssq) && (it < itermax)) {
res = 0.0;
exchange(solver);
for( int j=1; j<jmaxLocal+1; j++ ) {
for( int i=1; i<imax+1; i++ ) {
for (int j = 1; j < jmaxLocal + 1; j++) {
for (int i = 1; i < imax + 1; i++) {
r = RHS(i,j) - ((P(i-1,j) - 2.0 * P(i,j) + P(i+1,j)) * idx2 +
(P(i,j-1) - 2.0 *P(i,j) + P(i,j+1)) * idy2);
r = RHS(i, j) - ((P(i - 1, j) - 2.0 * P(i, j) + P(i + 1, j)) * idx2 +
(P(i, j - 1) - 2.0 * P(i, j) + P(i, j + 1)) * idy2);
P(i,j) -= (factor * r);
P(i, j) -= (factor * r);
res += (r * r);
}
}
if ( solver->rank == 0 ) {
for( int i=1; i<imax+1; i++ ) {
P(i,0) = P(i,1);
if (solver->rank == 0) {
for (int i = 1; i < imax + 1; i++) {
P(i, 0) = P(i, 1);
}
}
if ( solver->rank == (solver->size-1) ) {
for( int i=1; i<imax+1; i++ ) {
P(i,jmaxLocal+1) = P(i,jmaxLocal);
if (solver->rank == (solver->size - 1)) {
for (int i = 1; i < imax + 1; i++) {
P(i, jmaxLocal + 1) = P(i, jmaxLocal);
}
}
for( int j=1; j<jmaxLocal+1; j++ ) {
P(0,j) = P(1,j);
P(imax+1, j) = P(imax, j);
for (int j = 1; j < jmaxLocal + 1; j++) {
P(0, j) = P(1, j);
P(imax + 1, j) = P(imax, j);
}
MPI_Allreduce(&res, &res1, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
res = res1;
res = sqrt(res / (imax*jmax));
res = sqrt(res / (imax * jmax));
#ifdef DEBUG
if ( solver->rank == 0 ) {
printf("%d Residuum: %e\n",it, res1);
if (solver->rank == 0) {
printf("%d Residuum: %e\n", it, res1);
}
#endif
it++;
}
if ( solver->rank == 0 ) {
printf("Solver took %d iterations\n",it);
if (solver->rank == 0) {
printf("Solver took %d iterations\n", it);
}
if( res < eps ){
if (res < eps) {
return 1;
} else{
} else {
return 0;
}
}
@@ -261,22 +275,22 @@ int solveRB(Solver* solver)
int it = 0;
double res, res1;
int imax = solver->imax;
int jmax = solver->jmax;
int imax = solver->imax;
int jmax = solver->jmax;
int jmaxLocal = solver->jmaxLocal;
double eps= solver->eps;
double omega = solver->omega;
int itermax = solver->itermax;
double eps = solver->eps;
double omega = solver->omega;
int itermax = solver->itermax;
double dx2 = solver->dx * solver->dx;
double dy2 = solver->dy * solver->dy;
double idx2 = 1.0/dx2;
double idy2 = 1.0/dy2;
double factor = omega * 0.5 * (dx2*dy2) / (dx2+dy2);
double* p = solver->p;
double* rhs = solver->rhs;
double dx2 = solver->dx * solver->dx;
double dy2 = solver->dy * solver->dy;
double idx2 = 1.0 / dx2;
double idy2 = 1.0 / dy2;
double factor = omega * 0.5 * (dx2 * dy2) / (dx2 + dy2);
double* p = solver->p;
double* rhs = solver->rhs;
int pass, jsw, isw;
double epssq = eps * eps;
double epssq = eps * eps;
res = eps + 1.0;
@@ -304,7 +318,7 @@ int solveRB(Solver* solver)
}
for (int i = 1; i < imax + 1; i++) {
P(i, 0) = P(i, 1);
P(i, 0) = P(i, 1);
P(i, jmaxLocal + 1) = P(i, jmaxLocal);
}
@@ -321,12 +335,12 @@ int solveRB(Solver* solver)
it++;
}
if ( solver->rank == 0 ) {
printf("Solver took %d iterations\n",it);
if (solver->rank == 0) {
printf("Solver took %d iterations\n", it);
}
if( res < eps ){
if (res < eps) {
return 1;
} else{
} else {
return 0;
}
}
@@ -337,24 +351,23 @@ int solveRBA(Solver* solver)
int it = 0;
double res;
int imax = solver->imax;
int jmax = solver->jmax;
int imax = solver->imax;
int jmax = solver->jmax;
int jmaxLocal = solver->jmaxLocal;
double eps= solver->eps;
double omega = solver->omega;
int itermax = solver->itermax;
double eps = solver->eps;
double omega = solver->omega;
int itermax = solver->itermax;
double dx2 = solver->dx * solver->dx;
double dy2 = solver->dy * solver->dy;
double idx2 = 1.0/dx2;
double idy2 = 1.0/dy2;
double factor = omega * 0.5 * (dx2*dy2) / (dx2+dy2);
double* p = solver->p;
double* rhs = solver->rhs;
double dx2 = solver->dx * solver->dx;
double dy2 = solver->dy * solver->dy;
double idx2 = 1.0 / dx2;
double idy2 = 1.0 / dy2;
double factor = omega * 0.5 * (dx2 * dy2) / (dx2 + dy2);
double* p = solver->p;
double* rhs = solver->rhs;
int pass, jsw, isw;
double rho = solver->rho;
double epssq = eps * eps;
double rho = solver->rho;
double epssq = eps * eps;
res = eps + 1.0;
@@ -384,7 +397,7 @@ int solveRBA(Solver* solver)
}
for (int i = 1; i < imax + 1; i++) {
P(i, 0) = P(i, 1);
P(i, 0) = P(i, 1);
P(i, jmaxLocal + 1) = P(i, jmaxLocal);
}
@@ -406,21 +419,21 @@ int solveRBA(Solver* solver)
void writeResult(Solver* solver, double* m, char* filename)
{
int imax = solver->imax;
int jmax = solver->jmax;
int imax = solver->imax;
int jmax = solver->jmax;
double* p = solver->p;
FILE *fp;
fp= fopen(filename, "w");
FILE* fp;
fp = fopen(filename, "w");
if (fp== NULL) {
if (fp == NULL) {
printf("Error!\n");
exit(EXIT_FAILURE);
}
for( int j=0; j<jmax+2; j++ ) {
for( int i=0; i<imax+2; i++ ) {
fprintf(fp, "%f ", m[j*(imax+2) + i]);
for (int j = 0; j < jmax + 2; j++) {
for (int i = 0; i < imax + 2; i++) {
fprintf(fp, "%f ", m[j * (imax + 2) + i]);
}
fprintf(fp, "\n");
}