FieldSolver.hpp

Go to the documentation of this file.

#ifndef OPAL_FIELD_SOLVER_H
#define OPAL_FIELD_SOLVER_H
 
#include <memory>
#include "BCHandler.hpp"
#include "Manager/BaseManager.h"
#include "Manager/FieldSolverBase.h"
 
// Define the FieldSolver class
template <typename T, unsigned Dim>
class FieldSolver : public ippl::FieldSolverBase<T, Dim> {
private:
    Field_t<Dim>* rho_m;
    VField_t<T, Dim>* E_m;
    Field_t<Dim>* phi_m;
 
    using BCHandler_t = BCHandler<Dim>;
    std::shared_ptr<BCHandler_t> bcHandler_m;
 
    size_t call_counter_m;
 
public:
    FieldSolver(
            std::string solver, Field_t<Dim>* rho, VField_t<T, Dim>* E, Field_t<Dim>* phi,
            std::shared_ptr<BCHandler_t> bcHandler)
        : ippl::FieldSolverBase<T, Dim>(solver),
          rho_m(rho),
          E_m(E),
          phi_m(phi),
          bcHandler_m(bcHandler),
          call_counter_m(0) {
        setPotentialBCs();
    }
 
    ~FieldSolver() override = default;
 
    void dumpScalField(std::string what);
    void dumpVectField(std::string what);
 
    Field_t<Dim>* getRho() { return rho_m; }
    void setRho(Field_t<Dim>* rho) { rho_m = rho; }
 
    VField_t<T, Dim>* getE() const { return E_m; }
    void setE(VField_t<T, Dim>* E) { E_m = E; }
 
    Field<T, Dim>* getPhi() const { return phi_m; }
    void setPhi(Field<T, Dim>* phi) { phi_m = phi; }
 
    std::shared_ptr<BCHandler_t> getBCHandler() const { return bcHandler_m; }
    void setBCHandler(std::shared_ptr<BCHandler_t> bcHandler) {
        bcHandler_m = bcHandler;
        setPotentialBCs();
    }
 
    T getCouplingConstant() const;
 
    void initOpenSolver();
 
    void initSolver() override;
 
    void setPotentialBCs();
 
    bool hasValidBCHandler() const { return (bcHandler_m != nullptr); }
 
    void runSolver() override {
        // The default runSolver should always count towards the call counter!
        runSolver(false);
    }
 
    void resetCallCounter() { call_counter_m = 0; }
 
    size_t getCallCounter() { return call_counter_m; }
 
    void runSolver(bool force_skip_field_dump);
 
    void runShiftedOpenSolver(const ippl::Vector<double, Dim>& shift);
 
    template <typename Solver>
    void initSolverWithParams(const ippl::ParameterList& sp);
 
    void initNullSolver();
 
    void initFFTSolver();
 
    void initCGSolver() {}
 
    void initP3MSolver() {}
};
 
// Explicit specialization declaration
template <>
void FieldSolver<double, 3>::initNullSolver();
 
#endif