void filter(fftwf_complex *box, int filter_type, float R){
int n_x, n_z, n_y;
float k_x, k_y, k_z, k_mag, kR;
// loop through k-box
#pragma omp parallel shared(box, filter_type, R) private(k_x, k_y, k_z, k_mag, kR, n_x, n_z, n_y)
{
#pragma omp for
for (n_x=0; n_x<DIM; n_x++){
if (n_x>MIDDLE) {k_x =(n_x-DIM) * DELTA_K;}
else {k_x = n_x * DELTA_K;}
for (n_y=0; n_y<DIM; n_y++){
if (n_y>MIDDLE) {k_y =(n_y-DIM) * DELTA_K;}
else {k_y = n_y * DELTA_K;}
for (n_z=0; n_z<=MIDDLE; n_z++){
k_z = n_z * DELTA_K;
k_mag = sqrt(k_x*k_x + k_y*k_y + k_z*k_z);
kR = k_mag*R; // real space top-hat
if (filter_type == 0){ // real space top-hat
if (kR > 1e-4){
box[C_INDEX(n_x, n_y, n_z)] *= 3.0 * (sin(kR)/pow(kR, 3) - cos(kR)/pow(kR, 2));
}
}
else if (filter_type == 1){ // k-space top hat
kR *= 0.413566994; // equates integrated volume to the real space top-hat (9pi/2)^(-1/3)
if (kR > 1){
box[C_INDEX(n_x, n_y, n_z)] = 0;
}
}
else if (filter_type == 2){ // gaussian
kR *= 0.643; // equates integrated volume to the real space top-hat
box[C_INDEX(n_x, n_y, n_z)] *= pow(E, -kR*kR/2.0);
}
else{
if ( (n_x==0) && (n_y==0) && (n_z==0) )
fprintf(stderr, "filter.c: Warning, filter type %i is undefined\nBox is unfiltered\n", filter_type);
}
}
}
} // end looping through k box
}
return;
}
doubleArray
calcPolynomials(doubleArray gamma, const int *ijk, const int *ijkIndex, const int ijkDim,
double *fac, const double tol, const double N,
const int la, doubleArray uspA,
const int lb, doubleArray uspB) {
int c1, c2, beta;
int ax, ay, az, bx, by, bz;
int alpha_x, alpha_y, alpha_z, beta_x, beta_y, beta_z;
int dax, day, daz, dbx, dby, dbz;
double bin_ax, bin_ay, bin_az, bin_bx, bin_by, bin_bz;
int p, q, r;
double factor;
/* array increments */
const int incG = gamma.dim[2];
const int incA1 = uspA.dim[3];
const int incA2 = uspA.dim[2]*uspA.dim[3];
const int incB1 = uspB.dim[3];
const int incB2 = uspB.dim[2]*uspB.dim[3];
doubleArray J = doubleArray_new(2, IJK_DIM(la), C_DIM(lb));
doubleArray I = doubleArray_new(2, IJK_DIM(la), IJK_DIM(lb));
const int incJ = J.dim[2];
const int incI = I.dim[2];
/* a) sums over alpha_x,y,z */
for(c1=0; c1<IJK_DIM(la); c1++) {
p = CIJK_INDEX(la,c1);
ax = ijk[p];
ay = ijk[p+1];
az = ijk[p+2];
for(alpha_x=0; alpha_x<=ax; alpha_x++) {
bin_ax = n_over_k(ax, alpha_x, fac);
dax = ax - alpha_x;
for(alpha_y=0; alpha_y<=ay; alpha_y++) {
bin_ay = bin_ax * n_over_k(ay, alpha_y, fac);
day = ay - alpha_y;
for(alpha_z=0; alpha_z<=az; alpha_z++) {
bin_az = bin_ay * n_over_k(az, alpha_z, fac);
daz = az - alpha_z;
factor = bin_az * uspA.array[dax*incA2 + day*incA1 + daz];
if (fabs(factor) <= tol)
continue;
r = ijkIndex[alpha_x*ijkDim*ijkDim + alpha_y*ijkDim + alpha_z];
for(beta=0; beta<=lb; beta++) {
for(c2=0; c2<IJK_DIM(beta); c2++) {
q = C_INDEX(beta,c2);
J.array[c1*incJ+q] += factor*gamma.array[r*incG+q];
}
}
}
}
}
}
/* b) sums over beta_x,y,z */
for(c2=0; c2<IJK_DIM(lb); c2++) {
q = CIJK_INDEX(lb,c2);
bx = ijk[q];
by = ijk[q+1];
bz = ijk[q+2];
for(beta_x=0; beta_x<=bx; beta_x++) {
bin_bx = n_over_k(bx, beta_x, fac);
dbx = bx - beta_x;
for(beta_y=0; beta_y<=by; beta_y++) {
bin_by = bin_bx * n_over_k(by, beta_y, fac);
dby = by - beta_y;
for(beta_z=0; beta_z<=bz; beta_z++) {
bin_bz = bin_by * n_over_k(bz, beta_z, fac);
dbz = bz - beta_z;
factor = bin_bz*uspB.array[dbx*incB2 + dby*incB1 + dbz];
if (fabs(factor) <= tol)
continue;
factor *= N;
r = ijkIndex[beta_x*ijkDim*ijkDim + beta_y*ijkDim + beta_z];
for(c1=0; c1<IJK_DIM(la); c1++) {
I.array[c1*incI+c2] += factor*J.array[c1*incJ+r];
}
}
}
}
}
doubleArray_free(gamma);
doubleArray_free(J);
return I;
}
