コード例 #1
0
ファイル: pngaussian.c プロジェクト: DonRegan/fastpm
void
fastpm_png_induce_correlation(FastPMPNGaussian * png, PM * pm, FastPMFloat * delta_k)
{
    FastPMFloat * g_x = pm_alloc(pm);
    png->Volume = pm->Volume;

    fastpm_ic_induce_correlation(pm, delta_k, (fastpm_fkfunc) fastpm_png_potential, png);

    pm_assign(pm, delta_k, g_x);
    pm_c2r(pm, g_x);

    fastpm_png_transform_potential(pm, g_x, png);

    pm_r2c(pm, g_x, delta_k);
    pm_free(pm, g_x);

    fastpm_apply_any_transfer(pm, delta_k, delta_k, (fastpm_fkfunc) fastpm_png_transfer_function, png);
}
コード例 #2
0
ファイル: solver-pm-grav.c プロジェクト: marcel-sl/fastpm
void
fastpm_calculate_forces(FastPM * fastpm, FastPMFloat * delta_k)
{
    PMStore * p = fastpm->base.p;
    PM * pm = fastpm->base.pm;
    FastPMPainter reader[1];
    fastpm_painter_init(reader, pm, FASTPM_PAINTER_CIC, 1);

    /* watch out: boost the density since mesh is finer than grid */
    double density_factor = pm->Norm / pow(1.0 * fastpm->nc, 3);

    CLOCK(ghosts);
    PMGhostData * pgd = pm_ghosts_create(pm, p, PACK_POS, NULL);
    LEAVE(ghosts);

    FastPMFloat * canvas = pm_alloc(pm);

    /* Watch out: this paints number of particles per cell. when pm_nc_factor is not 1, 
     * it is less than the density (a cell is smaller than the mean seperation between particles. 
     * We thus have to boost the density by density_factor.
     * */
    CLOCK(paint);
    fastpm_paint_store(fastpm->painter, canvas,
                p, p->np + pgd->nghosts, NULL, 0);
    fastpm_apply_multiply_transfer(pm, canvas, canvas, density_factor);
    LEAVE(paint);

    CLOCK(r2c);
    pm_r2c(pm, canvas, delta_k);
    LEAVE(r2c);

    /* calculate the forces save them to p->acc */

    switch(fastpm->DEALIASING_TYPE) {
        case FASTPM_DEALIASING_TWO_THIRD:
            {
            double k_nq = M_PI / pm->BoxSize[0] * pm->Nmesh[0];
            fastpm_apply_lowpass_transfer(pm, delta_k, delta_k, 2.0 / 3 * k_nq);
            }
        break;
        case FASTPM_DEALIASING_GAUSSIAN:
            apply_gaussian_dealiasing(pm, delta_k, delta_k, 1.0);
        break;
        case FASTPM_DEALIASING_AGGRESSIVE_GAUSSIAN:
            apply_gaussian_dealiasing(pm, delta_k, delta_k, 4.0);
        break;
        case FASTPM_DEALIASING_GAUSSIAN36:
            {
            double k_nq = M_PI / pm->BoxSize[0] * pm->Nmesh[0];
            fastpm_apply_any_transfer(pm, delta_k, delta_k, (fastpm_fkfunc) gaussian36, &k_nq);
        }
        break;
        case FASTPM_DEALIASING_NONE:
        break;
        default:
            fastpm_raise(-1, "wrong dealiasing kernel type");
    }


    int d;
    int ACC[] = {PACK_ACC_X, PACK_ACC_Y, PACK_ACC_Z};
    for(d = 0; d < 3; d ++) {
        CLOCK(transfer);
        switch(fastpm->KERNEL_TYPE) {
            case FASTPM_KERNEL_EASTWOOD:
                apply_force_kernel_eastwood(pm, delta_k, canvas, d, 1);
            break;
            case FASTPM_KERNEL_NAIVE:
                apply_force_kernel_eastwood(pm, delta_k, canvas, d, 0);
            break;
            case FASTPM_KERNEL_GADGET:
                apply_force_kernel_gadget(pm, delta_k, canvas, d, 1);
            break;
            case FASTPM_KERNEL_3_4:
                apply_force_kernel(pm, delta_k, canvas, d);
            break;
            case FASTPM_KERNEL_5_4:
                apply_force_kernel_5_4(pm, delta_k, canvas, d);
            break;
            case FASTPM_KERNEL_3_2:
                apply_force_kernel_3_2(pm, delta_k, canvas, d);
            break;
            default:
                fastpm_raise(-1, "Wrong kernel type\n");
        }

        LEAVE(transfer);

        CLOCK(c2r);
        pm_c2r(pm, canvas);
        LEAVE(c2r);

        CLOCK(readout);
        fastpm_readout_store(reader, canvas, p, p->np + pgd->nghosts, NULL, ACC[d]);
        LEAVE(readout);

        CLOCK(reduce);
        pm_ghosts_reduce(pgd, ACC[d]);
        LEAVE(reduce);
    }

    pm_free(pm, canvas);

    pm_ghosts_free(pgd);
}