FieldSolver.h

Go to the documentation of this file.

//
// Class FieldSolver
//   The class for the OPAL FIELDSOLVER command.
//   A FieldSolver definition is used by most physics commands to define the
//   particle charge and the reference momentum, together with some other data.
//
// Copyright (c) 200x - 2022, Paul Scherrer Institut, Villigen PSI, Switzerland
//
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef OPAL_FieldSolver_HH
#define OPAL_FieldSolver_HH

#include "AbstractObjects/Definition.h"
#include "Algorithms/PartData.h"
#include "Solvers/PoissonSolver.h"
#ifdef ENABLE_AMR
    #include "Amr/AmrObject.h"
    #include "Solvers/AmrPoissonSolver.h"
    #include <memory>
#endif

#include <string>

template <class T, unsigned Dim>
class PartBunchBase;

enum class FieldSolverType: short {
    NONE = -1,
    FFT,
    FFTBOX,
    SAAMG,
    P3M,
    FMG,
    ML,
    AMRMG,
    HYPRE,
    HPGMG
};


class FieldSolver: public Definition {

public:
    FieldSolver();

    virtual ~FieldSolver();

    virtual FieldSolver* clone(const std::string& name);

    static FieldSolver* find(const std::string& name);

    std::string getType();

    double getMX() const;

    double getMY() const;

    double getMT() const;

    void setMX(double);

    void setMY(double);

    void setMT(double);

    virtual void update();

    virtual void execute();

    void initCartesianFields();

    void initSolver(PartBunchBase<double, 3>* b);

    bool hasValidSolver();

    void setFieldSolverType();
    FieldSolverType getFieldSolverType() const;

    inline Layout_t& getParticleLayout() { return* PL_m; }

    FieldLayout_t* getFieldLayout() { return FL_m; }

    Inform& printInfo(Inform& os) const;

    unsigned int getInteractionRadius() {return (unsigned int) rpp_m; }

    bool hasPeriodicZ();

    bool isAmrSolverType() const;

#ifdef ENABLE_AMR
    AmrObject* getAmrObject() {
        return itsAmrObject_mp.get();
    }

    const AmrObject* getAmrObject() const {
        return itsAmrObject_mp.get();
    }
#endif

    PoissonSolver* solver_m;

private:
#ifdef ENABLE_AMR

    std::string getTagging_m() const;

    void initAmrObject_m();

    void initAmrSolver_m();

    std::unique_ptr<AmrObject> itsAmrObject_mp;
#endif

    // Not implemented.
    FieldSolver(const FieldSolver&);
    void operator=(const FieldSolver&);

    // Clone constructor.
    FieldSolver(const std::string& name, FieldSolver* parent);

    Mesh_t* mesh_m;

    FieldLayout_t* FL_m;

    std::unique_ptr<Layout_t> PL_m;

    PartBunchBase<double, 3>* itsBunch_m;

    std::string fsName_m;
    FieldSolverType fsType_m;

    double rpp_m;
};

inline
FieldSolverType FieldSolver::getFieldSolverType() const {
    return fsType_m;
}

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

#endif // OPAL_FieldSolver_HH