FFTBoxPoissonSolver.h

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 *
 * FFTBoxPoissonSolver.hh
 *
 * Open BC in x,y and z.
 *
 *
 *
 *
 *
 *
 ***************************************************************************/

// This class contains methods for solving Poisson's equation for the
// space charge portion of the calculation.

#ifndef FFT_BOXPOISSON_SOLVER_H_
#define FFT_BOXPOISSON_SOLVER_H_

#include "PoissonSolver.h"

#include "FFT/FFT.h"

class PartBunch;

class FFTBoxPoissonSolver : public PoissonSolver {
public:
    typedef FFT<SineTransform, 3, double>            SINE_t;

    // constructor and destructor
    FFTBoxPoissonSolver(PartBunch &bunch, std::string greensFuntion);

    FFTBoxPoissonSolver(Mesh_t *mesh, FieldLayout_t *fl, std::string greensFunction, double boxSize);

    ~FFTBoxPoissonSolver();

    // given a charge-density field rho and a set of mesh spacings hr,
    // compute the scalar potential with image charges at  -z
    void computePotential(Field_t &rho, Vector_t hr, double zshift);

    // given a charge-density field rho and a set of mesh spacings hr,
    // compute the scalar potential in open space
    void computePotential(Field_t &rho, Vector_t hr);

    // compute the green's function for a Poisson problem and put it in in grntm_m
    // uses grnIField_m to eliminate excess calculation in greenFunction()
    // given mesh information in nr and hr
    void greensFunction();

    void integratedGreensFunction();

    void shiftedIntGreensFunction(double zshift);

    double getXRangeMin(unsigned short /*level*/) {return -a_m;}
    double getXRangeMax(unsigned short /*level*/) {return  a_m;}
    double getYRangeMin(unsigned short /*level*/) {return -a_m;}
    double getYRangeMax(unsigned short /*level*/) {return  a_m;}
    double getZRangeMin(unsigned short /*level*/) {return -a_m; }
    double getZRangeMax(unsigned short /*level*/) {return  a_m; }
        void test(PartBunchBase<double, 3> */*bunch*/) { }


    Inform &print(Inform &os) const;

private:

    // rho2_m is the charge-density field with mesh doubled in each dimension
    Field_t rho2_m;

    // grntr_m is the Fourier transformed Green's function
    Field_t grntr_m;

    // Fields used to eliminate excess calculation in greensFunction()
    // mesh2_m and layout2_m are used
    IField_t grnIField_m[3];

    SINE_t *sine_m;

    // mesh and layout objects for rho_m
    Mesh_t *mesh_m;
    FieldLayout_t *layout_m;

    // mesh and layout objects for rho2_m
    Mesh_t *mesh2_m;
    FieldLayout_t *layout2_m;

    // tmp
    Field_t tmpgreen;

    // domains for the various fields
    NDIndex<3> domain_m;             // original domain, gridsize
    // mesh and gridsize defined outside of FFT class, given as
    // parameter to the constructor (mesh and layout object).
    NDIndex<3> domain2_m;            // doubled gridsize (2*Nx,2*Ny,2*Nz)
    // (2*Nx,Ny,2*Nz)
    // mesh spacing and size values
    Vector_t hr_m;
    Vektor<int, 3> nr_m;

    std::string greensFunction_m;

    double a_m; // the box size

    IpplTimings::TimerRef GreensFunctionTimer_m;

    IpplTimings::TimerRef IntGreensFunctionTimer1_m;
    IpplTimings::TimerRef IntGreensFunctionTimer2_m;
    IpplTimings::TimerRef IntGreensFunctionTimer3_m;
    IpplTimings::TimerRef IntGreensFunctionTimer4_m;

    IpplTimings::TimerRef ShIntGreensFunctionTimer1_m;
    IpplTimings::TimerRef ShIntGreensFunctionTimer2_m;
    IpplTimings::TimerRef ShIntGreensFunctionTimer3_m;
    IpplTimings::TimerRef ShIntGreensFunctionTimer4_m;

    IpplTimings::TimerRef GreensFunctionTimer1_m;
    IpplTimings::TimerRef GreensFunctionTimer4_m;
};

inline Inform &operator<<(Inform &os, const FFTBoxPoissonSolver &fs) {
    return fs.print(os);
}



#endif