Poisson.h

//
// Class Poisson
//   Base class for solvers for the Poisson problem
//
 
#ifndef IPPL_POISSON_H
#define IPPL_POISSON_H
 
#include "Utility/ParameterList.h"
 
#include "Field/Field.h"
 
namespace ippl {
 
    template <typename FieldLHS, typename FieldRHS>
    class Poisson {
        constexpr static unsigned Dim = FieldLHS::dim;
        typedef typename FieldLHS::Mesh_t Mesh;
        typedef typename FieldLHS::Centering_t Centering;
        typedef typename Mesh::matrix_type Matrix_t;
        typedef Field<Matrix_t, Dim, Mesh, Centering> MField_t;
 
    public:
        using lhs_type = FieldLHS;
        using rhs_type = FieldRHS;
        using Tlhs     = typename FieldLHS::value_type;
        using Trhs     = typename FieldRHS::value_type;
 
        using grad_type = Field<Vector<Tlhs, Dim>, Dim, Mesh, Centering>;
 
        enum OutputType {
            SOL          = 0b01,
            GRAD         = 0b10,
            SOL_AND_GRAD = 0b11
        };
 
        Poisson()
            : grad_mp(nullptr) {
            static_assert(std::is_floating_point<Trhs>::value, "Not a floating point type");
            setDefaultParameters();
        }
 
        Poisson(lhs_type& lhs, rhs_type& rhs)
            : grad_mp(nullptr) {
            setLhs(lhs);
            setRhs(rhs);
 
            static_assert(std::is_floating_point<Trhs>::value, "Not a floating point type");
            setDefaultParameters();
        }
 
        template <typename T>
        void updateParameter(const std::string& key, const T& value) {
            params_m.update<T>(key, value);
        }
 
        void updateParameters(const ParameterList& params) { params_m.update(params); }
 
        void mergeParameters(const ParameterList& params) { params_m.merge(params); }
 
        virtual void setLhs(lhs_type& lhs) { lhs_mp = &lhs; }
 
        virtual void setRhs(rhs_type& rhs) { rhs_mp = &rhs; }
 
        virtual MField_t* getHessian() { return nullptr; }
 
        void setGradient(grad_type& grad) { grad_mp = &grad; }
 
        virtual void solve() = 0;
 
        virtual ~Poisson() {}
 
    protected:
        ParameterList params_m;
 
        rhs_type* rhs_mp = nullptr;
        lhs_type* lhs_mp = nullptr;
 
        grad_type* grad_mp;
 
        virtual void setDefaultParameters() { this->params_m.add("output_type", SOL); }
    };
}  // namespace ippl
 
#endif