From f7ffbe3016f13946da07696b72871e8a09e32693 Mon Sep 17 00:00:00 2001
From: unknown <>
Date: Fri, 15 Mar 2024 18:17:34 -0400
Subject: [PATCH] cleanup macro

---
 .vscode/settings.json           |   3 +-
 src/main/c/includes/utilities.h |   2 +-
 src/main/c/src/densitystep.c    |  20 +++---
 src/main/c/src/velocitystep.c   | 112 ++++++++++++++++----------------
 4 files changed, 69 insertions(+), 68 deletions(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 5d1101b..f878489 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -15,6 +15,7 @@
         "electrosphere_fluidsim.h": "c",
         "type_traits": "c",
         "mainfunctions.h": "c",
-        "chunk.h": "c"
+        "chunk.h": "c",
+        "simulation.h": "c"
     }
 }
\ No newline at end of file
diff --git a/src/main/c/includes/utilities.h b/src/main/c/includes/utilities.h
index 05bd973..ab128a5 100644
--- a/src/main/c/includes/utilities.h
+++ b/src/main/c/includes/utilities.h
@@ -6,7 +6,7 @@
 #define SWAP(x0,x) {float *tmp=x0;x0=x;x=tmp;}
 #define IX(i,j,k) ((i)+(N)*(j)+(N*N)*(k))
 #define CK(m,n,o) ((m)+(n)*(3)+(o)*(3)*(3))
-#define GET_ARR_RAW(env,src,i) src[i]
+#define GET_ARR_RAW(src,i) src[i]
 #define ARR_EXISTS(chunk_mask,m,n,o) (chunk_mask & CHUNK_INDEX_ARR[CK(m,n,o)]) > 0
 
 #endif
\ No newline at end of file
diff --git a/src/main/c/src/densitystep.c b/src/main/c/src/densitystep.c
index f3a9326..0cd1266 100644
--- a/src/main/c/src/densitystep.c
+++ b/src/main/c/src/densitystep.c
@@ -18,8 +18,8 @@ static inline void addDensity(
 ){
     int i;
     int size=N*N*N;
-    float * x = GET_ARR_RAW(env,d,CENTER_LOC);
-    float * s = GET_ARR_RAW(env,d0,CENTER_LOC);
+    float * x = GET_ARR_RAW(d,CENTER_LOC);
+    float * s = GET_ARR_RAW(d0,CENTER_LOC);
     for(i=0; i<size; i++){
         x[i] += dt*s[i];
     }
@@ -43,8 +43,8 @@ static inline void solveDiffuseDensity(
     float a=dt*DIFFUSION_CONST*N*N*N;
     float c=1+6*a;
     int i, j, k, l, m;
-    float * x = GET_ARR_RAW(env,d,CENTER_LOC);
-    float * x0 = GET_ARR_RAW(env,d0,CENTER_LOC);
+    float * x = GET_ARR_RAW(d,CENTER_LOC);
+    float * x0 = GET_ARR_RAW(d0,CENTER_LOC);
     
     __m256 aScalar = _mm256_set1_ps(a);
     __m256 cScalar = _mm256_set1_ps(c);
@@ -86,17 +86,17 @@ static inline void advectDensity(uint32_t chunk_mask, int N, float ** d, float *
     
     dtx=dty=dtz=dt*N;
 
-    float * center_d = GET_ARR_RAW(env,d,CENTER_LOC);
-    float * center_d0 = GET_ARR_RAW(env,d0,CENTER_LOC);
+    float * center_d = GET_ARR_RAW(d,CENTER_LOC);
+    float * center_d0 = GET_ARR_RAW(d0,CENTER_LOC);
 
-    float * u = GET_ARR_RAW(env,ur,CENTER_LOC);
-    float * v = GET_ARR_RAW(env,vr,CENTER_LOC);
-    float * w = GET_ARR_RAW(env,wr,CENTER_LOC);
+    float * u = GET_ARR_RAW(ur,CENTER_LOC);
+    float * v = GET_ARR_RAW(vr,CENTER_LOC);
+    float * w = GET_ARR_RAW(wr,CENTER_LOC);
 
     for(k=1; k<N-1; k++){
         for(j=1; j<N-1; j++){
             for(i=1; i<N-1; i++){
-                center_d0 = GET_ARR_RAW(env,d0,CENTER_LOC);
+                center_d0 = GET_ARR_RAW(d0,CENTER_LOC);
                 //calculate location to pull from
                 x = i-dtx*u[IX(i,j,k)];
                 y = j-dty*v[IX(i,j,k)];
diff --git a/src/main/c/src/velocitystep.c b/src/main/c/src/velocitystep.c
index 66fad18..6666534 100644
--- a/src/main/c/src/velocitystep.c
+++ b/src/main/c/src/velocitystep.c
@@ -36,9 +36,9 @@ static inline void addSourceToVectors
   float DIFFUSION_CONST,
   float VISCOSITY_CONST,
   float dt){
-    add_source(N,GET_ARR_RAW(env,jru,CENTER_LOC),GET_ARR_RAW(env,jru0,CENTER_LOC),dt);
-    add_source(N,GET_ARR_RAW(env,jrv,CENTER_LOC),GET_ARR_RAW(env,jrv0,CENTER_LOC),dt);
-    add_source(N,GET_ARR_RAW(env,jrw,CENTER_LOC),GET_ARR_RAW(env,jrw0,CENTER_LOC),dt);
+    add_source(N,GET_ARR_RAW(jru,CENTER_LOC),GET_ARR_RAW(jru0,CENTER_LOC),dt);
+    add_source(N,GET_ARR_RAW(jrv,CENTER_LOC),GET_ARR_RAW(jrv0,CENTER_LOC),dt);
+    add_source(N,GET_ARR_RAW(jrw,CENTER_LOC),GET_ARR_RAW(jrw0,CENTER_LOC),dt);
 }
 
 /**
@@ -71,12 +71,12 @@ static inline void solveVectorDiffuse (
     float a=dt*VISCOSITY_CONST*N*N*N;
     float c=1+6*a;
     int i, j, k, l, m;
-    float * u = GET_ARR_RAW(env,jru,CENTER_LOC);
-    float * v = GET_ARR_RAW(env,jrv,CENTER_LOC);
-    float * w = GET_ARR_RAW(env,jrw,CENTER_LOC);
-    float * u0 = GET_ARR_RAW(env,jru0,CENTER_LOC);
-    float * v0 = GET_ARR_RAW(env,jrv0,CENTER_LOC);
-    float * w0 = GET_ARR_RAW(env,jrw0,CENTER_LOC);
+    float * u = GET_ARR_RAW(jru,CENTER_LOC);
+    float * v = GET_ARR_RAW(jrv,CENTER_LOC);
+    float * w = GET_ARR_RAW(jrw,CENTER_LOC);
+    float * u0 = GET_ARR_RAW(jru0,CENTER_LOC);
+    float * v0 = GET_ARR_RAW(jrv0,CENTER_LOC);
+    float * w0 = GET_ARR_RAW(jrw0,CENTER_LOC);
     
     __m256 aScalar = _mm256_set1_ps(a);
     __m256 cScalar = _mm256_set1_ps(c);
@@ -182,12 +182,12 @@ static inline void setupProjection(
     __m256 zeroVec = _mm256_set1_ps(0);
     __m256 vector, vector2, vector3;
 
-    float * u = GET_ARR_RAW(env,ur,CENTER_LOC);
-    float * v = GET_ARR_RAW(env,vr,CENTER_LOC);
-    float * w = GET_ARR_RAW(env,wr,CENTER_LOC);
+    float * u = GET_ARR_RAW(ur,CENTER_LOC);
+    float * v = GET_ARR_RAW(vr,CENTER_LOC);
+    float * w = GET_ARR_RAW(wr,CENTER_LOC);
 
-    float * p = GET_ARR_RAW(env,pr,CENTER_LOC);
-    float * div = GET_ARR_RAW(env,divr,CENTER_LOC);
+    float * p = GET_ARR_RAW(pr,CENTER_LOC);
+    float * div = GET_ARR_RAW(divr,CENTER_LOC);
 
     float scalar = 1.0/3.0;
     float h = 1.0/N;
@@ -265,8 +265,8 @@ static inline void solveProjection(
     __m256 aScalar = _mm256_set1_ps(a);
     __m256 cScalar = _mm256_set1_ps(c);
 
-    float * p = GET_ARR_RAW(env,jru0,CENTER_LOC);
-    float * div = GET_ARR_RAW(env,jrv0,CENTER_LOC);
+    float * p = GET_ARR_RAW(jru0,CENTER_LOC);
+    float * div = GET_ARR_RAW(jrv0,CENTER_LOC);
     // update for each cell
     for(k=1; k<N-1; k++){
         for(j=1; j<N-1; j++){
@@ -314,12 +314,12 @@ static inline void finalizeProjection(
     __m256 constScalar = _mm256_set1_ps(0.5f*N);
     __m256 vector, vector2, vector3;
 
-    float * u = GET_ARR_RAW(env,jru,CENTER_LOC);
-    float * v = GET_ARR_RAW(env,jrv,CENTER_LOC);
-    float * w = GET_ARR_RAW(env,jrw,CENTER_LOC);
+    float * u = GET_ARR_RAW(jru,CENTER_LOC);
+    float * v = GET_ARR_RAW(jrv,CENTER_LOC);
+    float * w = GET_ARR_RAW(jrw,CENTER_LOC);
 
-    float * p = GET_ARR_RAW(env,jru0,CENTER_LOC);
-    float * div = GET_ARR_RAW(env,jrv0,CENTER_LOC);
+    float * p = GET_ARR_RAW(jru0,CENTER_LOC);
+    float * div = GET_ARR_RAW(jrv0,CENTER_LOC);
 
     for ( k=1 ; k<N-1 ; k++ ) {
         for ( j=1 ; j<N-1 ; j++ ) {
@@ -394,9 +394,9 @@ static inline void advectVectors(
   float VISCOSITY_CONST,
   float dt
 ){
-    advect(chunk_mask,N,1,jru,jru0,GET_ARR_RAW(env,jru0,CENTER_LOC),GET_ARR_RAW(env,jrv0,CENTER_LOC),GET_ARR_RAW(env,jrw0,CENTER_LOC),dt);
-    advect(chunk_mask,N,2,jrv,jrv0,GET_ARR_RAW(env,jru0,CENTER_LOC),GET_ARR_RAW(env,jrv0,CENTER_LOC),GET_ARR_RAW(env,jrw0,CENTER_LOC),dt);
-    advect(chunk_mask,N,3,jrw,jrw0,GET_ARR_RAW(env,jru0,CENTER_LOC),GET_ARR_RAW(env,jrv0,CENTER_LOC),GET_ARR_RAW(env,jrw0,CENTER_LOC),dt);
+    advect(chunk_mask,N,1,jru,jru0,GET_ARR_RAW(jru0,CENTER_LOC),GET_ARR_RAW(jrv0,CENTER_LOC),GET_ARR_RAW(jrw0,CENTER_LOC),dt);
+    advect(chunk_mask,N,2,jrv,jrv0,GET_ARR_RAW(jru0,CENTER_LOC),GET_ARR_RAW(jrv0,CENTER_LOC),GET_ARR_RAW(jrw0,CENTER_LOC),dt);
+    advect(chunk_mask,N,3,jrw,jrw0,GET_ARR_RAW(jru0,CENTER_LOC),GET_ARR_RAW(jrv0,CENTER_LOC),GET_ARR_RAW(jrw0,CENTER_LOC),dt);
 }
 
 /**
@@ -409,14 +409,14 @@ static inline void advect(uint32_t chunk_mask, int N, int b, float ** jrd, float
     
     dtx=dty=dtz=dt*N;
 
-    float * d = GET_ARR_RAW(env,jrd,CENTER_LOC);
+    float * d = GET_ARR_RAW(jrd,CENTER_LOC);
 
-    float * d0 = GET_ARR_RAW(env,jrd0,CENTER_LOC);
+    float * d0 = GET_ARR_RAW(jrd0,CENTER_LOC);
 
     for(k=1; k<N-1; k++){
         for(j=1; j<N-1; j++){
             for(i=1; i<N-1; i++){
-                d0 = GET_ARR_RAW(env,jrd0,CENTER_LOC);
+                d0 = GET_ARR_RAW(jrd0,CENTER_LOC);
                 //calculate location to pull from
                 x = i-dtx*u[IX(i,j,k)];
                 y = j-dty*v[IX(i,j,k)];
@@ -482,7 +482,7 @@ static inline void advect(uint32_t chunk_mask, int N, int b, float ** jrd, float
 
 
                     // printf("Hit other chunk\n");
-                    d0 = GET_ARR_RAW(env,jrd0,CK(m,n,o));
+                    d0 = GET_ARR_RAW(jrd0,CK(m,n,o));
                     x = x + CHUNK_NORMALIZE_U[CK(m,n,o)] * (N-2);
                     // printf("%d => %f\n",m,x);
                     y = y + CHUNK_NORMALIZE_V[CK(m,n,o)] * (N-2);
@@ -654,7 +654,7 @@ static inline void setBoundsToNeighborsRaw(
   float ** neighborArray
 ){
     int DIM = N;
-    float * target = GET_ARR_RAW(env,neighborArray,CENTER_LOC);
+    float * target = GET_ARR_RAW(neighborArray,CENTER_LOC);
     float * source;
     //set the faces bounds
     for(int x=1; x < DIM-1; x++){
@@ -710,7 +710,7 @@ static inline void copyNeighborsRaw(
   float ** neighborArray
 ){
     int DIM = N;
-    float * target = GET_ARR_RAW(env,neighborArray,CENTER_LOC);
+    float * target = GET_ARR_RAW(neighborArray,CENTER_LOC);
     float * source;
 
 
@@ -729,7 +729,7 @@ static inline void copyNeighborsRaw(
     //_mm256_loadu_ps
     //_mm256_storeu_ps
     if(ARR_EXISTS(chunk_mask,0,1,1)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,1,1));
+        source = GET_ARR_RAW(neighborArray,CK(0,1,1));
         for(int x=1; x < DIM-1; x++){
             // transferVector = _mm512_loadu_ps(&source[IX(DIM-2,x,1)]);
             // _mm512_storeu_ps(&target[IX(0,x,1)],_mm512_loadu_ps(&source[IX(DIM-2,x,1)]));
@@ -740,7 +740,7 @@ static inline void copyNeighborsRaw(
     }
 
     if(ARR_EXISTS(chunk_mask,2,1,1)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,1,1));
+        source = GET_ARR_RAW(neighborArray,CK(2,1,1));
         for(int x=1; x < DIM-1; x++){
             // _mm512_storeu_ps(&target[IX(DIM-1,x,1)],_mm512_loadu_ps(&source[IX(1,x,1)]));
             for(int y = 1; y < DIM-1; y++){
@@ -750,7 +750,7 @@ static inline void copyNeighborsRaw(
     }
 
     if(ARR_EXISTS(chunk_mask,1,0,1)){
-        source = GET_ARR_RAW(env,neighborArray,CK(1,0,1));
+        source = GET_ARR_RAW(neighborArray,CK(1,0,1));
         for(int x=1; x < DIM-1; x++){
             for(int y = 1; y < DIM-1; y++){
                 target[IX(x,0,y)] = source[IX(x,DIM-2,y)];
@@ -759,7 +759,7 @@ static inline void copyNeighborsRaw(
     }
 
     if(ARR_EXISTS(chunk_mask,1,2,1)){
-        source = GET_ARR_RAW(env,neighborArray,CK(1,2,1));
+        source = GET_ARR_RAW(neighborArray,CK(1,2,1));
         for(int x=1; x < DIM-1; x++){
             for(int y = 1; y < DIM-1; y++){
                 target[IX(x,DIM-1,y)] = source[IX(x,1,y)];
@@ -768,7 +768,7 @@ static inline void copyNeighborsRaw(
     }
 
     if(ARR_EXISTS(chunk_mask,1,1,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(1,1,0));
+        source = GET_ARR_RAW(neighborArray,CK(1,1,0));
         for(int x=1; x < DIM-1; x++){
             for(int y = 1; y < DIM-1; y++){
                 target[IX(x,y,0)] = source[IX(x,y,DIM-2)];
@@ -777,7 +777,7 @@ static inline void copyNeighborsRaw(
     }
 
     if(ARR_EXISTS(chunk_mask,1,1,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(1,1,2));
+        source = GET_ARR_RAW(neighborArray,CK(1,1,2));
         for(int x=1; x < DIM-1; x++){
             for(int y = 1; y < DIM-1; y++){
                 target[IX(x,y,DIM-1)] = source[IX(x,y,1)];
@@ -792,28 +792,28 @@ static inline void copyNeighborsRaw(
     //
     //
     if(ARR_EXISTS(chunk_mask,0,0,1)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,0,1));
+        source = GET_ARR_RAW(neighborArray,CK(0,0,1));
         for(int x=1; x < DIM-1; x++){
                 target[IX(0,0,x)] = source[IX(DIM-2,DIM-2,x)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,2,0,1)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,0,1));
+        source = GET_ARR_RAW(neighborArray,CK(2,0,1));
         for(int x=1; x < DIM-1; x++){
                 target[IX(DIM-1,0,x)] = source[IX(1,DIM-2,x)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,0,2,1)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,2,1));
+        source = GET_ARR_RAW(neighborArray,CK(0,2,1));
         for(int x=1; x < DIM-1; x++){
                 target[IX(0,DIM-1,x)] = source[IX(DIM-2,1,x)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,2,2,1)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,2,1));
+        source = GET_ARR_RAW(neighborArray,CK(2,2,1));
         for(int x=1; x < DIM-1; x++){
                 target[IX(DIM-1,DIM-1,x)] = source[IX(1,1,x)];
         }
@@ -823,28 +823,28 @@ static inline void copyNeighborsRaw(
     //
 
     if(ARR_EXISTS(chunk_mask,0,1,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,1,0));
+        source = GET_ARR_RAW(neighborArray,CK(0,1,0));
         for(int x=1; x < DIM-1; x++){
                 target[IX(0,x,0)] = source[IX(DIM-2,x,DIM-2)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,2,1,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,1,0));
+        source = GET_ARR_RAW(neighborArray,CK(2,1,0));
         for(int x=1; x < DIM-1; x++){
                 target[IX(DIM-1,x,0)] = source[IX(1,x,DIM-2)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,0,1,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,1,2));
+        source = GET_ARR_RAW(neighborArray,CK(0,1,2));
         for(int x=1; x < DIM-1; x++){
                 target[IX(0,x,DIM-1)] = source[IX(DIM-2,x,1)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,2,1,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,1,2));
+        source = GET_ARR_RAW(neighborArray,CK(2,1,2));
         for(int x=1; x < DIM-1; x++){
                 target[IX(DIM-1,x,DIM-1)] = source[IX(1,x,1)];
         }
@@ -854,28 +854,28 @@ static inline void copyNeighborsRaw(
     //
 
     if(ARR_EXISTS(chunk_mask,1,0,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(1,0,0));
+        source = GET_ARR_RAW(neighborArray,CK(1,0,0));
         for(int x=1; x < DIM-1; x++){
                 target[IX(x,0,0)] = source[IX(x,DIM-2,DIM-2)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,1,2,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(1,2,0));
+        source = GET_ARR_RAW(neighborArray,CK(1,2,0));
         for(int x=1; x < DIM-1; x++){
                 target[IX(x,DIM-1,0)] = source[IX(x,1,DIM-2)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,1,0,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(1,0,2));
+        source = GET_ARR_RAW(neighborArray,CK(1,0,2));
         for(int x=1; x < DIM-1; x++){
                 target[IX(x,0,DIM-1)] = source[IX(x,DIM-2,1)];
         }
     }
 
     if(ARR_EXISTS(chunk_mask,1,2,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(1,2,2));
+        source = GET_ARR_RAW(neighborArray,CK(1,2,2));
         for(int x=1; x < DIM-1; x++){
                 target[IX(x,DIM-1,DIM-1)] = source[IX(x,1,1)];
         }
@@ -889,22 +889,22 @@ static inline void copyNeighborsRaw(
     //
 
     if(ARR_EXISTS(chunk_mask,0,0,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,0,0));
+        source = GET_ARR_RAW(neighborArray,CK(0,0,0));
         target[IX(0,0,0)] = source[IX(DIM-2,DIM-2,DIM-2)];
     }
 
     if(ARR_EXISTS(chunk_mask,2,0,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,0,0));
+        source = GET_ARR_RAW(neighborArray,CK(2,0,0));
         target[IX(DIM-1,0,0)] = source[IX(1,DIM-2,DIM-2)];
     }
 
     if(ARR_EXISTS(chunk_mask,0,2,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,2,0));
+        source = GET_ARR_RAW(neighborArray,CK(0,2,0));
         target[IX(0,DIM-1,0)] = source[IX(DIM-2,1,DIM-2)];
     }
 
     if(ARR_EXISTS(chunk_mask,2,2,0)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,2,0));
+        source = GET_ARR_RAW(neighborArray,CK(2,2,0));
         target[IX(DIM-1,DIM-1,0)] = source[IX(1,1,DIM-2)];
     }
 
@@ -912,22 +912,22 @@ static inline void copyNeighborsRaw(
     //
 
     if(ARR_EXISTS(chunk_mask,0,0,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,0,2));
+        source = GET_ARR_RAW(neighborArray,CK(0,0,2));
         target[IX(0,0,DIM-1)] = source[IX(DIM-2,DIM-2,1)];
     }
 
     if(ARR_EXISTS(chunk_mask,2,0,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,0,2));
+        source = GET_ARR_RAW(neighborArray,CK(2,0,2));
         target[IX(DIM-1,0,DIM-1)] = source[IX(1,DIM-2,1)];
     }
 
     if(ARR_EXISTS(chunk_mask,0,2,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(0,2,2));
+        source = GET_ARR_RAW(neighborArray,CK(0,2,2));
         target[IX(0,DIM-1,DIM-1)] = source[IX(DIM-2,1,1)];
     }
 
     if(ARR_EXISTS(chunk_mask,2,2,2)){
-        source = GET_ARR_RAW(env,neighborArray,CK(2,2,2));
+        source = GET_ARR_RAW(neighborArray,CK(2,2,2));
         target[IX(DIM-1,DIM-1,DIM-1)] = source[IX(1,1,1)];
     }