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

2
BasicSolver/2D-seq/backstep.par
View File

@@ -15,7 +15,7 @@ bcRight 3 #
gx 0.0 # Body forces (e.g. gravity)
gy 0.0 #
re 36500.0 # Reynolds number
re 7500.0 # Reynolds number
u_init 1.0 # initial value for velocity in x-direction
v_init 0.0 # initial value for velocity in y-direction

6
BasicSolver/2D-seq/dcavity.par
View File

@@ -17,7 +17,7 @@ gy 0.0 #
re 10.0 # Reynolds number
u_init 0.0 # initial value for velocity in x-direction
u_init 1.0 # initial value for velocity in x-direction
v_init 0.0 # initial value for velocity in y-direction
p_init 0.0 # initial value for pressure
@@ -48,9 +48,9 @@ gamma 0.9 # upwind differencing factor gamma
# Particle Tracing Data:
# -----------------------
numberOfParticles 30
numberOfParticles 200
startTime 0
injectTimePeriod 2.0
injectTimePeriod 0.5
writeTimePeriod 0.2
x1 0.1

18900
BasicSolver/2D-seq/pressure.dat
View File

File diff suppressed because it is too large Load Diff

17
BasicSolver/2D-seq/src/solver.h
View File

@@ -8,9 +8,20 @@
#define __SOLVER_H_
#include "parameter.h"
enum OBJECTBOUNDARY { NONE = 0, TOP, BOTTOM, LEFT, RIGHT, TOPLEFT, BOTTOMLEFT, TOPRIGHT, BOTTOMRIGHT, LOCAL };
enum OBJECTBOUNDARY {
NONE = 0,
TOP,
BOTTOM,
LEFT,
RIGHT,
TOPLEFT,
BOTTOMLEFT,
TOPRIGHT,
BOTTOMRIGHT,
LOCAL
};
enum BC { NOSLIP = 1, SLIP, OUTFLOW, PERIODIC };
/// @brief
/// @brief
enum SHAPE { NOSHAPE = 0, RECT, CIRCLE };
typedef struct {
@@ -22,7 +33,7 @@ typedef struct {
double *p, *rhs;
double *f, *g;
double *u, *v;
int *s;
int* s;
/* parameters */
double eps, omega, rho;
double re, tau, gamma;

18900
BasicSolver/2D-seq/velocity.dat
View File

File diff suppressed because it is too large Load Diff

BIN
BasicSolver/2D-seq/velocity.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 188 KiB

After

Width:  |  Height:  |  Size: 208 KiB

6
BasicSolver/2D-seq/vis_files/animate.plot
View File

@@ -1,8 +1,8 @@
unset border; unset tics; unset key;
set term gif animate delay 50
set term gif animate delay 30
set output "trace.gif"
set xrange [0:7]
set yrange [0:1.5]
set xrange [0:1]
set yrange [0:1]
do for [ts=0:120] {
plot "particles_".ts.".dat" with points pointtype 7

BIN
BasicSolver/2D-seq/vis_files/trace.gif
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 453 KiB

After

Width:  |  Height:  |  Size: 478 KiB

74
BasicSolver/3D-seq/backstep.par Normal file
View File

@@ -0,0 +1,74 @@
#==============================================================================
# Laminar Canal Flow
#==============================================================================
# Problem specific Data:
# ---------------------
name backstep # name of flow setup
bcTop 1 # flags for boundary conditions
bcBottom 1 # 1 = no-slip 3 = outflow
bcLeft 3 # 2 = free-slip 4 = periodic
bcRight 3 #
gx 0.0 # Body forces (e.g. gravity)
gy 0.0 #
re 36500.0 # Reynolds number
u_init 1.0 # initial value for velocity in x-direction
v_init 0.0 # initial value for velocity in y-direction
p_init 1.0 # initial value for pressure
# Geometry Data:
# -------------
xlength 7.0 # domain size in x-direction
ylength 1.5 # domain size in y-direction
imax 210 # number of interior cells in x-direction
jmax 45 # number of interior cells in y-direction
# Time Data:
# ---------
te 60.0 # final time
dt 0.02 # time stepsize
tau 0.5 # safety factor for time stepsize control (<0 constant delt)
# Pressure Iteration Data:
# -----------------------
itermax 500 # maximal number of pressure iteration in one time step
eps 0.0001 # stopping tolerance for pressure iteration
rho 0.52
omg 1.8 # relaxation parameter for SOR iteration
gamma 0.9 # upwind differencing factor gamma
# Particle Tracing Data:
# -----------------------
numberOfParticles 200
startTime 0
injectTimePeriod 1.0
writeTimePeriod 0.5
x1 0.0
y1 0.5
x2 0.0
y2 1.5
# Obstacle Geometry Data:
# -----------------------
# Shape 0 disable, 1 Rectangle/Square, 2 Circle
shape 1
xCenter 0.0
yCenter 0.0
zCenter 0.0
xRectLength 2.0
yRectLength 1.0
zRectLength 1.0
circleRadius 1.0
#===============================================================================

21
BasicSolver/3D-seq/canal.par
View File

@@ -31,14 +31,14 @@ p_init 0.0 # initial value for pressure
xlength 30.0 # domain size in x-direction
ylength 4.0 # domain size in y-direction
zlength 4.0 # domain size in z-direction
imax 40 # number of interior cells in x-direction
jmax 10 # number of interior cells in y-direction
kmax 10 # number of interior cells in z-direction
imax 100 # number of interior cells in x-direction
jmax 40 # number of interior cells in y-direction
kmax 40 # number of interior cells in z-direction
# Time Data:
# ---------
te 100.0 # final time
te 60.0 # final time
dt 0.02 # time stepsize
tau 0.5 # safety factor for time stepsize control (<0 constant delt)
@@ -65,4 +65,17 @@ z1 1.0
x2 1.0
y2 4.0
z2 1.0
# Obstacle Geometry Data:
# -----------------------
# Shape 0 disable, 1 Rectangle/Square, 2 Circle
shape 2
xCenter 10.0
yCenter 2.0
zCenter 2.0
xRectLength 8.0
yRectLength 2.0
zRectLength 2.0
circleRadius 1.0
#===============================================================================

13
BasicSolver/3D-seq/dcavity.par
View File

@@ -65,4 +65,17 @@ z1 1.0
x2 1.0
y2 4.0
z2 1.0
# Obstacle Geometry Data:
# -----------------------
# Shape 0 disable, 1 Rectangle/Square, 2 Circle
shape 1
xCenter 10.0
yCenter 2.0
zCenter 2.0
xRectLength 8.0
yRectLength 2.0
zRectLength 2.0
circleRadius 1.0
#===============================================================================

85
BasicSolver/3D-seq/karman.par Normal file
View File

@@ -0,0 +1,85 @@
#==============================================================================
# Laminar Canal Flow
#==============================================================================
# Problem specific Data:
# ---------------------
name karman # name of flow setup
bcTop 1 # flags for boundary conditions
bcBottom 1 # 1 = no-slip 3 = outflow
bcLeft 3 # 2 = free-slip 4 = periodic
bcRight 3 #
gx 0.0 # Body forces (e.g. gravity)
gy 0.0 #
re 5050.0 # Reynolds number
u_init 1.0 # initial value for velocity in x-direction
v_init 0.0 # initial value for velocity in y-direction
p_init 0.0 # initial value for pressure
# Geometry Data:
# -------------
xlength 30.0 # domain size in x-direction
ylength 8.0 # domain size in y-direction
imax 400 # number of interior cells in x-direction
jmax 200 # number of interior cells in y-direction
# Time Data:
# ---------
te 150.0 # final time
dt 0.02 # time stepsize
tau 0.5 # safety factor for time stepsize control (<0 constant delt)
# Pressure Iteration Data:
# -----------------------
itermax 200 # maximal number of pressure iteration in one time step
eps 0.001 # stopping tolerance for pressure iteration
rho 0.52
omg 1.75 # relaxation parameter for SOR iteration
gamma 0.9 # upwind differencing factor gamma
# Particle Tracing Data:
# -----------------------
numberOfParticles 200
startTime 50
injectTimePeriod 1.0
writeTimePeriod 0.5
x1 0.0
y1 3.8
x2 0.0
y2 4.1
# Obstacle Geometry Data:
# -----------------------
# Shape 0 disable, 1 Rectangle/Square, 2 Circle
shape 2
xCenter 5.0
yCenter 4.0
xRectLength 2.0
yRectLength 1.0
circleRadius 1.0
# Obstacle Geometry Data:
# -----------------------
# Shape 0 disable, 1 Rectangle/Square, 2 Circle
shape 1
xCenter 10.0
yCenter 2.0
zCenter 2.0
xRectLength 8.0
yRectLength 2.0
zRectLength 2.0
circleRadius 1.0
#===============================================================================

1929
BasicSolver/3D-seq/sample.txt Normal file
View File

File diff suppressed because it is too large Load Diff

16
BasicSolver/3D-seq/src/main.c
View File

@@ -12,18 +12,16 @@
#include "allocate.h"
#include "parameter.h"
#include "particletracing.h"
#include "progress.h"
#include "solver.h"
#include "timing.h"
#include "vtkWriter.h"
#include "particletracing.h"
#define G(v, i, j, k) v[(k) * (imax + 2) * (jmax + 2) + (j) * (imax + 2) + (i)]
enum VARIANT { SOR = 1, RB, RBA };
static void createBulkArrays(Solver* s, double* pg, double* ug, double* vg, double* wg)
{
int imax = s->grid.imax;
@@ -87,8 +85,7 @@ int main(int argc, char** argv)
}
readParameter(&params, argv[1]);
if (argc == 3)
{
if (argc == 3) {
variant = atoi(argv[2]);
}
printParameter(&params);
@@ -103,14 +100,19 @@ int main(int argc, char** argv)
double te = s.te;
double t = 0.0;
printGrid(&s, s.seg);
exit(0);
timeStart = getTimeStamp();
void (*solver_generic[])() = {solve, solveRB, solveRBA};
void (*solver_generic[])() = { solve, solveRB, solveRBA };
while (t <= te) {
if (tau > 0.0) computeTimestep(&s);
setBoundaryConditions(&s);
setSpecialBoundaryCondition(&s);
setObjectBoundaryCondition(&s);
computeFG(&s);
computeRHS(&s);
solver_generic[variant - 1](&s);
@@ -119,7 +121,7 @@ int main(int argc, char** argv)
trace(&particletracer, s.u, s.v, s.w, t);
t += s.dt;
#ifdef VERBOSE
if (rank == 0) {
printf("TIME %f , TIMESTEP %f\n", t, s.dt);

9
BasicSolver/3D-seq/src/parameter.c
View File

@@ -101,6 +101,15 @@ void readParameter(Parameter* param, const char* filename)
PARSE_REAL(y2);
PARSE_REAL(z2);
/* Added obstacle geometry parameters */
PARSE_INT(shape);
PARSE_REAL(xCenter);
PARSE_REAL(yCenter);
PARSE_REAL(zCenter);
PARSE_REAL(xRectLength);
PARSE_REAL(yRectLength);
PARSE_REAL(zRectLength);
PARSE_REAL(circleRadius);
}
}

9
BasicSolver/3D-seq/src/parameter.h
View File

@@ -23,9 +23,12 @@ typedef struct {
double startTime, injectTimePeriod, writeTimePeriod;
double x1, y1, z1, x2, y2, z2;
int shape;
double xCenter, yCenter, zCenter, xRectLength, yRectLength, zRectLength, circleRadius;
} Parameter;
void initParameter(Parameter*);
void readParameter(Parameter*, const char*);
void printParameter(Parameter*);
extern void initParameter(Parameter*);
extern void readParameter(Parameter*, const char*);
extern void printParameter(Parameter*);
#endif

28
BasicSolver/3D-seq/src/particletracing.h
View File

@@ -8,20 +8,20 @@
#define __PARTICLETRACING_H_
#include "allocate.h"
#include "parameter.h"
#include "solver.h"
#include "particletracing.h"
#include "solver.h"
#include <stdbool.h>
typedef enum COORD { X = 0, Y, NCOORD } COORD;
typedef struct
{
typedef struct {
double x, y, z;
bool flag;
} Particle;
typedef struct {
int numberOfParticles, totalParticles;
double startTime, injectTimePeriod, writeTimePeriod, lastInjectTime, lastUpdateTime, lastWriteTime;
double startTime, injectTimePeriod, writeTimePeriod, lastInjectTime, lastUpdateTime,
lastWriteTime;
int estimatedNumParticles, activeParticles;
@@ -30,19 +30,19 @@ typedef struct {
Particle* particlePool;
int pointer;
double imax, jmax, kmax, xlength, ylength, zlength;
double x1, y1, x2, y2, z1, z2;
} ParticleTracer;
void initParticleTracer(ParticleTracer*, Parameter*);
void injectParticles(ParticleTracer*);
void advanceParticles(ParticleTracer*, double* , double*, double*, double);
void freeParticles(ParticleTracer*);
void writeParticles(ParticleTracer*);
void printParticleTracerParameters(ParticleTracer*);
void printParticles(ParticleTracer*);
void compress(ParticleTracer*);
void trace(ParticleTracer*, double* , double* , double* , double);
extern void initParticleTracer(ParticleTracer*, Parameter*);
extern void injectParticles(ParticleTracer*);
extern void advanceParticles(ParticleTracer*, double*, double*, double*, double);
extern void freeParticles(ParticleTracer*);
extern void writeParticles(ParticleTracer*);
extern void printParticleTracerParameters(ParticleTracer*);
extern void printParticles(ParticleTracer*);
extern void compress(ParticleTracer*);
extern void trace(ParticleTracer*, double*, double*, double*, double);
#endif

500
BasicSolver/3D-seq/src/solver.c
View File

@@ -22,8 +22,122 @@
#define U(i, j, k) u[(k) * (imax + 2) * (jmax + 2) + (j) * (imax + 2) + (i)]
#define V(i, j, k) v[(k) * (imax + 2) * (jmax + 2) + (j) * (imax + 2) + (i)]
#define W(i, j, k) w[(k) * (imax + 2) * (jmax + 2) + (j) * (imax + 2) + (i)]
#define S(i, j, k) seg[(k) * (imax + 2) * (jmax + 2) + (j) * (imax + 2) + (i)]
#define RHS(i, j, k) rhs[(k) * (imax + 2) * (jmax + 2) + (j) * (imax + 2) + (i)]
static double distance(
double i, double j, double k, double iCenter, double jCenter, double kCenter)
{
return sqrt(pow(iCenter - i, 2) + pow(jCenter - j, 2) + pow(kCenter - k, 2) * 1.0);
}
void printGrid(Solver* solver, int* grid)
{
int imax = solver->grid.imax;
int jmax = solver->grid.jmax;
for (int k = 0; k < solver->grid.kmax + 2; k++) {
printf("K : %02d:\n", k);
for (int j = 0; j < solver->grid.jmax + 2; j++) {
printf("J : %02d: ", j);
for (int i = 0; i < solver->grid.imax + 2; i++) {
switch (grid[(k) * (imax + 2) * (jmax + 2) + (j) * (imax + 2) + (i)]) {
case FRONTFACE:
printf("FF ");
break;
case BACKFACE:
printf("BF ");
break;
case LEFTFACE:
printf("LF ");
break;
case RIGHTFACE:
printf("RF ");
break;
case TOPFACE:
printf("TF ");
break;
case BOTTOMFACE:
printf("BMF ");
break;
case FRONTTOPLEFTCORNER:
printf("FTLC ");
break;
case FRONTTOPRIGHTCORNER:
printf("FTRC ");
break;
case FRONTBOTTOMLEFTCORNER:
printf("FBLC ");
break;
case FRONTBOTTOMRIGHTCORNER:
printf("FBRC ");
break;
case BACKTOPLEFTCORNER:
printf("BTLC ");
break;
case BACKTOPRIGHTCORNER:
printf("BTRC ");
break;
case BACKBOTTOMLEFTCORNER:
printf("BBLC ");
break;
case BACKBOTTOMRIGHTCORNER:
printf("BBRC ");
break;
case FRONTTOPLINE:
printf("FTL ");
break;
case FRONTBOTTOMLINE:
printf("FBL ");
break;
case FRONTLEFTLINE:
printf("FLL ");
break;
case FRONTRIGHTLINE:
printf("FRL ");
break;
case MIDTOPLEFTLINE:
printf("MTLL ");
break;
case MIDTOPRIGHTLINE:
printf("MTRL ");
break;
case MIDBOTTOMLEFTLINE:
printf("MBTL ");
break;
case MIDBOTTOMRIGHTLINE:
printf("MBRL ");
break;
case BACKTOPLINE:
printf("BTL ");
break;
case BACKBOTTOMLINE:
printf("BBL ");
break;
case BACKLEFTLINE:
printf("BLL ");
break;
case BACKRIGHTLINE:
printf("BRL ");
break;
case LOCAL:
printf("L ");
break;
case NONE:
printf("N ");
break;
}
}
printf("\n");
}
printf("\n\n");
}
fflush(stdout);
}
static void printConfig(Solver* s)
{
printf("Parameters for #%s#\n", s->problem);
@@ -85,7 +199,6 @@ void initSolver(Solver* s, Parameter* params)
s->gamma = params->gamma;
s->rho = params->rho;
int imax = s->grid.imax;
int jmax = s->grid.jmax;
int kmax = s->grid.kmax;
@@ -98,6 +211,7 @@ void initSolver(Solver* s, Parameter* params)
s->f = allocate(64, bytesize);
s->g = allocate(64, bytesize);
s->h = allocate(64, bytesize);
s->seg = allocate(64, bytesize);
for (int i = 0; i < (imax + 2) * (jmax + 2) * (kmax + 2); i++) {
s->u[i] = params->u_init;
@@ -108,6 +222,7 @@ void initSolver(Solver* s, Parameter* params)
s->f[i] = 0.0;
s->g[i] = 0.0;
s->h[i] = 0.0;
s->seg[i] = NONE;
}
double dx = s->grid.dx;
@@ -117,6 +232,194 @@ void initSolver(Solver* s, Parameter* params)
double invSqrSum = 1.0 / (dx * dx) + 1.0 / (dy * dy) + 1.0 / (dz * dz);
s->dtBound = 0.5 * s->re * 1.0 / invSqrSum;
double xCenter = 0, yCenter = 0, zCenter = 0, radius = 0;
double x1 = 0, x2 = 0, y1 = 0, y2 = 0, z1 = 0, z2 = 0;
int* seg = s->seg;
switch (params->shape) {
case NOSHAPE:
break;
case RECT:
x1 = params->xCenter - params->xRectLength / 2;
x2 = params->xCenter + params->xRectLength / 2;
y1 = params->yCenter - params->yRectLength / 2;
y2 = params->yCenter + params->yRectLength / 2;
z1 = params->zCenter - params->zRectLength / 2;
z2 = params->zCenter + params->zRectLength / 2;
for (int k = 1; k < kmax + 1; k++) {
for (int j = 1; j < jmax + 1; j++) {
for (int i = 1; i < imax + 1; i++) {
if ((x1 <= (i * dx)) && ((i * dx) <= x2) && (y1 <= (j * dy)) &&
((j * dy) <= y2) && ((z1 <= (k * dz)) && ((k * dz) <= z2))) {
S(i, j, k) = LOCAL;
}
}
}
}
break;
case CIRCLE:
xCenter = params->xCenter;
yCenter = params->yCenter;
zCenter = params->zCenter;
radius = params->circleRadius;
for (int k = 1; k < kmax + 1; k++) {
for (int j = 1; j < jmax + 1; j++) {
for (int i = 1; i < imax + 1; i++) {
if (distance((i * dx),
(j * dy),
(k * dz),
xCenter,
yCenter,
zCenter) <= radius) {
S(i, j, k) = LOCAL;
}
}
}
}
break;
default:
break;
}
for (int k = 1; k < kmax + 1; k++) {
for (int j = 1; j < jmax + 1; j++) {
for (int i = 1; i < imax + 1; i++) {
/* Assigning enum values to Corners */
if (S(i - 1, j + 1, k - 1) == NONE && S(i - 1, j, k) == NONE &&
S(i, j + 1, k) == NONE && S(i, j, k - 1) == NONE &&
S(i + 1, j - 1, k + 1) == LOCAL && S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTTOPLEFTCORNER; //
}
if (S(i + 1, j + 1, k - 1) == NONE && S(i + 1, j, k) == NONE &&
S(i, j + 1, k) == NONE && S(i, j, k - 1) == NONE &&
S(i - 1, j - 1, k + 1) == LOCAL && S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTTOPRIGHTCORNER; //
}
if (S(i - 1, j - 1, k - 1) == NONE && S(i - 1, j, k) == NONE &&
S(i, j - 1, k) == NONE && S(i, j, k - 1) == NONE &&
S(i + 1, j + 1, k + 1) == LOCAL && S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTBOTTOMLEFTCORNER; //
}
if (S(i + 1, j - 1, k - 1) == NONE && S(i + 1, j, k) == NONE &&
S(i, j - 1, k) == NONE && S(i, j, k - 1) == NONE &&
S(i - 1, j + 1, k + 1) == LOCAL && S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTBOTTOMRIGHTCORNER; //
}
if (S(i - 1, j + 1, k + 1) == NONE && S(i - 1, j, k) == NONE &&
S(i, j + 1, k) == NONE && S(i, j, k + 1) == NONE &&
S(i + 1, j - 1, k - 1) == LOCAL && S(i, j, k) == LOCAL) {
S(i, j, k) = BACKTOPLEFTCORNER; //
}
if (S(i + 1, j + 1, k + 1) == NONE && S(i + 1, j, k) == NONE &&
S(i, j + 1, k) == NONE && S(i, j, k + 1) == NONE &&
S(i - 1, j - 1, k - 1) == LOCAL && S(i, j, k) == LOCAL) {
S(i, j, k) = BACKTOPRIGHTCORNER;
}
if (S(i - 1, j - 1, k + 1) == NONE && S(i - 1, j, k) == NONE &&
S(i, j - 1, k) == NONE && S(i, j, k + 1) == NONE &&
S(i + 1, j + 1, k - 1) == LOCAL && S(i, j, k) == LOCAL) {
S(i, j, k) = BACKBOTTOMLEFTCORNER;
}
if (S(i + 1, j - 1, k + 1) == NONE && S(i + 1, j, k) == NONE &&
S(i, j - 1, k) == NONE && S(i, j, k + 1) == NONE &&
S(i - 1, j + 1, k - 1) == LOCAL && S(i, j, k) == LOCAL) {
S(i, j, k) = BACKBOTTOMRIGHTCORNER;
}
/* Assigning enum values to Lines */
if (S(i - 1, j, k - 1) == NONE && S(i, j, k - 1) == NONE &&
S(i - 1, j, k) == NONE && S(i + 1, j, k + 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTLEFTLINE;
}
if (S(i + 1, j, k - 1) == NONE && S(i + 1, j, k) == NONE &&
S(i, j, k - 1) == NONE && S(i - 1, j, k + 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTRIGHTLINE;
}
if (S(i, j + 1, k - 1) == NONE && S(i, j + 1, k) == NONE &&
S(i, j, k - 1) == NONE && S(i, j - 1, k + 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTTOPLINE;
}
if (S(i, j - 1, k - 1) == NONE && S(i, j, k - 1) == NONE &&
S(i, j - 1, k) == NONE && S(i, j + 1, k + 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTBOTTOMLINE;
}
if (S(i - 1, j + 1, k) == NONE && S(i, j + 1, k) == NONE &&
S(i - 1, j, k) == NONE && S(i + 1, j - 1, k) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = MIDTOPLEFTLINE;
}
if (S(i + 1, j + 1, k) == NONE && S(i + 1, j, k) == NONE &&
S(i, j + 1, k) == NONE && S(i - 1, j - 1, k) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = MIDTOPRIGHTLINE;
}
if (S(i - 1, j - 1, k) == NONE && S(i - 1, j, k) == NONE &&
S(i, j - 1, k) == NONE && S(i + 1, j + 1, k) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = MIDBOTTOMLEFTLINE;
}
if (S(i + 1, j - 1, k) == NONE && S(i + 1, j, k) == NONE &&
S(i, j - 1, k) == NONE && S(i - 1, j + 1, k) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = MIDBOTTOMRIGHTLINE;
}
if (S(i - 1, j, k + 1) == NONE && S(i - 1, j, k) == NONE &&
S(i, j, k + 1) == NONE && S(i + 1, j, k - 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = BACKLEFTLINE;
}
if (S(i + 1, j, k + 1) == NONE && S(i + 1, j, k) == NONE &&
S(i, j, k + 1) == NONE && S(i - 1, j, k - 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = BACKRIGHTLINE;
}
if (S(i, j + 1, k + 1) == NONE && S(i, j + 1, k) == NONE &&
S(i, j, k + 1) == NONE && S(i, j - 1, k - 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = BACKTOPLINE;
}
if (S(i, j - 1, k + 1) == NONE && S(i, j - 1, k) == NONE &&
S(i, j, k + 1) == NONE && S(i, j + 1, k - 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = BACKBOTTOMLINE;
}
/* Assigning enum values to Faces */
if (S(i, j, k - 1) == NONE && S(i, j, k + 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = FRONTFACE; //
}
if (S(i, j, k + 1) == NONE && S(i, j, k - 1) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = BACKFACE; //
}
if (S(i, j - 1, k) == NONE && S(i, j + 1, k) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = BOTTOMFACE; //
}
if (S(i, j + 1, k) == NONE && S(i, j - 1, k) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = TOPFACE; //
}
if (S(i - 1, j, k) == NONE && S(i + 1, j, k) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = LEFTFACE; //
}
if (S(i + 1, j, k) == NONE && S(i - 1, j, k) == LOCAL &&
S(i, j, k) == LOCAL) {
S(i, j, k) = RIGHTFACE; //
}
}
}
}
#ifdef VERBOSE
printConfig(s);
#endif /* VERBOSE */
@@ -321,15 +624,14 @@ void solveRBA(Solver* s)
double idx2 = 1.0 / dx2;
double idy2 = 1.0 / dy2;
double idz2 = 1.0 / dz2;
double factor = 0.5 * (dx2 * dy2 * dz2) /
(dy2 * dz2 + dx2 * dz2 + dx2 * dy2);
double* p = s->p;
double* rhs = s->rhs;
double epssq = eps * eps;
double factor = 0.5 * (dx2 * dy2 * dz2) / (dy2 * dz2 + dx2 * dz2 + dx2 * dy2);
double* p = s->p;
double* rhs = s->rhs;
double epssq = eps * eps;
double rho = s->rho;
double omega = 1.0;
int it = 0;
double res = 1.0;
int it = 0;
double res = 1.0;
int pass, ksw, jsw, isw;
while ((res >= epssq) && (it < itermax)) {
@@ -359,7 +661,7 @@ void solveRBA(Solver* s)
}
jsw = 3 - jsw;
}
ksw = 3 - ksw;
ksw = 3 - ksw;
omega = (it == 0 && pass == 0 ? 1.0 / (1.0 - 0.5 * rho * rho)
: 1.0 / (1.0 - 0.25 * rho * rho * omega));
}
@@ -676,6 +978,19 @@ void setSpecialBoundaryCondition(Solver* s)
U(0, j, k) = y * (ylength - y) * 4.0 / (ylength * ylength);
}
}
} else if (strcmp(s->problem, "karman") == 0) {
for (int k = 1; k < kmax + 1; k++) {
for (int j = 1; j < jmax + 1; j++) {
U(0, j, k) = 1.0;
}
}
} else if (strcmp(s->problem, "backstep") == 0) {
for (int k = 1; k < kmax + 1; k++) {
for (int j = 1; j < jmax + 1; j++) {
U(0, j, k) = 1.0;
}
}
}
}
@@ -896,3 +1211,170 @@ void adaptUV(Solver* s)
}
}
}
void setObjectBoundaryCondition(Solver* s)
{
int imax = s->grid.imax;
int jmax = s->jmax;
int kmax = s->kmax;
double* u = s->u;
double* v = s->v;
double* w = s->w;
int* seg = s->seg;
for (int k = 1; k < kmax + 1; k++) {
for (int j = 1; j < jmax + 1; j++) {
for (int i = 1; i < imax + 1; i++) {
switch (S(i, j, k)) {
case TOPFACE:
U(i, j, k) = -U(i, j + 1, k);
U(i - 1, j, k) = -U(i - 1, j + 1, k);
V(i, j, k) = 0.0;
W(i, j, k) = 0.0;
break;
case BOTTOMFACE:
U(i, j, k) = -U(i, j - 1, k);
U(i - 1, j, k) = -U(i - 1, j - 1, k);
V(i, j, k) = 0.0;
W(i, j, k) = 0.0;
break;
case LEFTFACE:
U(i - 1, j, k) = 0.0;
V(i, j, k) = -V(i - 1, j, k);
V(i, j - 1, k) = -V(i - 1, j - 1, k);
W(i, j, k) = 0.0;
break;
case RIGHTFACE:
U(i, j, k) = 0.0;
V(i, j, k) = -V(i + 1, j, k);
V(i, j - 1, k) = -V(i + 1, j - 1, k);
W(i, j, k) = 0.0;
break;
case FRONTFACE:
U(i - 1, j, k) = 0.0;
V(i, j, k) = 0.0;
V(i, j, k) = -V(i - 1, j, k);
V(i, j - 1, k) = -V(i - 1, j - 1, k);
break;
case BACKFACE:
U(i, j, k) = 0.0;
V(i, j, k) = 0.0;
V(i, j, k) = -V(i + 1, j, k);
V(i, j - 1, k) = -V(i + 1, j - 1, k);
break;
case TOPLEFT:
U(i, j) = -U(i, j + 1);
U(i - 1, j) = 0.0;
V(i, j) = 0.0;
V(i, j - 1) = -V(i - 1, j - 1);
break;
case TOPRIGHT:
U(i, j) = 0.0;
U(i - 1, j) = -U(i - 1, j + 1);
V(i, j) = 0.0;
V(i, j - 1) = -V(i + 1, j - 1);
break;
case BOTTOMLEFT:
U(i, j) = -U(i, j - 1);
U(i - 1, j) = 0.0;
V(i, j) = -V(i - 1, j);
V(i, j - 1) = 0.0;
break;
case BOTTOMRIGHT:
U(i, j) = 0.0;
U(i - 1, j) = -U(i - 1, j - 1);
V(i, j) = -V(i, j + 1);
V(i, j - 1) = 0.0;
break;
case TOP:
U(i, j) = -U(i, j + 1);
U(i - 1, j) = -U(i - 1, j + 1);
V(i, j) = 0.0;
break;
case BOTTOM:
U(i, j) = -U(i, j - 1);
U(i - 1, j) = -U(i - 1, j - 1);
V(i, j) = 0.0;
break;
case LEFT:
U(i - 1, j) = 0.0;
V(i, j) = -V(i - 1, j);
V(i, j - 1) = -V(i - 1, j - 1);
break;
case RIGHT:
U(i, j) = 0.0;
V(i, j) = -V(i + 1, j);
V(i, j - 1) = -V(i + 1, j - 1);
break;
case TOPLEFT:
U(i, j) = -U(i, j + 1);
U(i - 1, j) = 0.0;
V(i, j) = 0.0;
V(i, j - 1) = -V(i - 1, j - 1);
break;
case TOPRIGHT:
U(i, j) = 0.0;
U(i - 1, j) = -U(i - 1, j + 1);
V(i, j) = 0.0;
V(i, j - 1) = -V(i + 1, j - 1);
break;
case BOTTOMLEFT:
U(i, j) = -U(i, j - 1);
U(i - 1, j) = 0.0;
V(i, j) = -V(i - 1, j);
V(i, j - 1) = 0.0;
break;
case BOTTOMRIGHT:
U(i, j) = 0.0;
U(i - 1, j) = -U(i - 1, j - 1);
V(i, j) = -V(i, j + 1);
V(i, j - 1) = 0.0;
break;
case TOP:
U(i, j) = -U(i, j + 1);
U(i - 1, j) = -U(i - 1, j + 1);
V(i, j) = 0.0;
break;
case BOTTOM:
U(i, j) = -U(i, j - 1);
U(i - 1, j) = -U(i - 1, j - 1);
V(i, j) = 0.0;
break;
case LEFT:
U(i - 1, j) = 0.0;
V(i, j) = -V(i - 1, j);
V(i, j - 1) = -V(i - 1, j - 1);
break;
case RIGHT:
U(i, j) = 0.0;
V(i, j) = -V(i + 1, j);
V(i, j - 1) = -V(i + 1, j - 1);
break;
case TOPLEFT:
U(i, j) = -U(i, j + 1);
U(i - 1, j) = 0.0;
V(i, j) = 0.0;
V(i, j - 1) = -V(i - 1, j - 1);
break;
case TOPRIGHT:
U(i, j) = 0.0;
U(i - 1, j) = -U(i - 1, j + 1);
V(i, j) = 0.0;
V(i, j - 1) = -V(i + 1, j - 1);
break;
case BOTTOMLEFT:
U(i, j) = -U(i, j - 1);
U(i - 1, j) = 0.0;
V(i, j) = -V(i - 1, j);
V(i, j - 1) = 0.0;
break;
case BOTTOMRIGHT:
U(i, j) = 0.0;
U(i - 1, j) = -U(i - 1, j - 1);
V(i, j) = -V(i, j + 1);
V(i, j - 1) = 0.0;
break;
}
}
}
}
}

43
BasicSolver/3D-seq/src/solver.h
View File

@@ -10,7 +10,46 @@
#include "grid.h"
#include "parameter.h"
enum OBJECTBOUNDARY {
NONE = 0,
/* Front Corners */
FRONTTOPLEFTCORNER,
FRONTTOPRIGHTCORNER,
FRONTBOTTOMLEFTCORNER,
FRONTBOTTOMRIGHTCORNER,
/* Back Corners */
BACKTOPLEFTCORNER,
BACKTOPRIGHTCORNER,
BACKBOTTOMLEFTCORNER,
BACKBOTTOMRIGHTCORNER,
/* Faces */
FRONTFACE,
BACKFACE,
LEFTFACE,
RIGHTFACE,
TOPFACE,
BOTTOMFACE,
/* Front Lines remaining after Corners and Faces */
FRONTLEFTLINE,
FRONTRIGHTLINE,
FRONTTOPLINE,
FRONTBOTTOMLINE,
/* Bottom Lines remaining after Corners and Faces */
BACKLEFTLINE,
BACKRIGHTLINE,
BACKTOPLINE,
BACKBOTTOMLINE,
/* Mid Lines remaining after Corners and Faces */
MIDTOPLEFTLINE,
MIDTOPRIGHTLINE,
MIDBOTTOMLEFTLINE,
MIDBOTTOMRIGHTLINE,
/* Local where its an object but not a boundary */
LOCAL
};
enum BC { NOSLIP = 1, SLIP, OUTFLOW, PERIODIC };
/// @brief
enum SHAPE { NOSHAPE = 0, RECT, CIRCLE };
typedef struct {
/* geometry and grid information */
@@ -19,6 +58,7 @@ typedef struct {
double *p, *rhs;
double *f, *g, *h;
double *u, *v, *w;
int* seg;
/* parameters */
double eps, omega, rho;
double re, tau, gamma;
@@ -39,8 +79,11 @@ extern void solveRBA(Solver*);
extern void normalizePressure(Solver*);
extern void computeTimestep(Solver*);
extern void setBoundaryConditions(Solver*);
extern void setObjectBoundaryCondition(Solver*);
extern void setSpecialBoundaryCondition(Solver*);
extern void computeFG(Solver*);
extern void adaptUV(Solver*);
extern void writeResult(Solver*);
extern void printGrid(Solver*, int*);
#endif