wmsolver.h

Go to the documentation of this file.

#ifndef wmsolver_h
#define wmsolver_h
 
// WarpX solver includes
#include "hostactions/time_step/timestep_constraint.h"
#include "timestep_status.h"
#include "wmsolverbase.h"
 
// WarpX lib includes
#include "hostactions/wmhostaction.h"
#include "lib/wmdomain.h"
 
#include "hostactions/time_step/time_stepper_base.h"
 
// std includes
#include <map>
#include <string>
 
// forward declarations
class WmTaskGraphProcessor;
class WmSimulation;
class WmDomain;
class WmSubSolver;
class WmSequencedGroup;
class WmHostAction;
 
class WmSolver : public WmSolverBase
{
public:
    WmSolver(const WmSimulation* parentSim);
 
    virtual ~WmSolver();
 
    void setStartFrame(unsigned frame)
    {
        _startFrame = frame;
    }
 
    virtual void setup(const WxCryptSet& wxc);
 
    const WmDomain& getDomain() const;
 
    WmSubSolver* getSubSolver(const std::string& name) const;
 
    const wxm::variable::variable_t& getConstVar(const std::string& name) const
    {
        VariableMap_t::const_iterator i;
        i = _variables.find(name);
        if (i != _variables.end())
        {
            return (*i->second);
        }
        else
        {
            WxExcept wxe;
            wxe << "Variable " << name << " not found";
            throw wxe;
        }
    }
 
    wxm::variable::variable_t& getVar(const std::string& name) const
    {
        VariableMap_t::iterator i;
        VariableMap_t* p_variables = const_cast<VariableMap_t*>(
            &_variables); // TODO:: revisit this interface decision to const_cast.
                          // Originated from choice to make parent pointers in host
                          // actions const.
        i = p_variables->find(name);
        if (i != p_variables->end())
        {
            return (*i->second);
        }
        else
        {
            WxExcept wxe("WmSolver::getVar : ");
            wxe << "Variable " << name << " not found";
            throw wxe;
        }
    }
 
    const std::type_info& getVarType(const std::string& name) const;
 
    WmSequencedGroup& getSequencedGroup(const std::string& name)
    {
        SequencedGroupMap_t::iterator i;
        i = _sequencedGroups.find(name);
        if (i != _sequencedGroups.end())
        {
            return *i->second;
        }
        else
        {
            WxExcept wxe;
            wxe << "WmSequencedGroup " << name << " not found";
            throw wxe;
        }
    }
 
    virtual void solve();
 
    void presolve();
 
    void step_dt(real limit_dt = 0);
 
    const solverParameters_t& getSolverParameters() const
    {
        return _solverParameters;
    }
 
    const std::vector<WmHostAction*>& getStartOnlyGroup() const
    {
        return _startOnlyG;
    }
 
    const std::vector<WmHostAction*>& getPerStepGroup() const
    {
        return _perStepG;
    }
 
private:
    WmSolver& operator=(const WmSolver& s);
    WmSolver(const WmSolver& s);
 
    void startOnly();
 
    void restart();
 
    void endOnly();
 
    void preRedoPerStep();
 
    void init()
    {
    }
 
    void finishBuild()
    {
    }
 
    void load(WxIoBase& io, const WxIoNodeType& grpNode)
    {
    }
 
    void dump(WxIoBase& io, WxIoNodeType& grpNode) const
    {
    }
 
    virtual WxStepperStatus step()
    {
        return WxStepperStatus();
    }
 
    std::pair<TimestepConstraint, TimestepDecision> advance(real tend);
 
    typedef std::map<std::string, wxm::variable::variable_t*> VariableMap_t;
    typedef std::pair<std::string, wxm::variable::variable_t*> VariablePair_t;
 
    typedef std::map<std::string, WmSubSolver*> SubSolverMap_t;
    typedef std::pair<std::string, WmSubSolver*> SubSolverPair_t;
 
    typedef std::map<std::string, WmHostAction*> HostActionMap_t;
    typedef std::pair<std::string, WmHostAction*> HostActionPair_t;
 
    typedef std::map<std::string, WmSequencedGroup*> SequencedGroupMap_t;
    typedef std::pair<std::string, WmSequencedGroup*> SequencedGroupPair_t;
 
    solverParameters_t _solverParameters;
 
    TimestepStatus _timestep_status;
 
    bool flexible_writeout;
 
    real _tstart, _tend;
    unsigned _startFrame;
    unsigned _nout;
 
    VariableMap_t _variables;
    SubSolverMap_t _subSolvers;
 
    HostActionMap_t _hostActions;
 
    SequencedGroupMap_t _sequencedGroups;
 
    WmDomain* _domain;
 
    bool enable_fpe;
 
    void add_host_actions(std::vector<WmHostAction*>& g, const std::string& name);
 
    std::vector<WmHostAction*> _startOnlyG;
    std::vector<WmHostAction*> _endOnlyG;
    std::vector<WmHostAction*> _perStepG;
    std::vector<WmHostAction*> _preRedoPerStepG;
    std::vector<WmHostAction*> _restartG;
    // what's used to calculate dt
    wxm::dt_calc::time_stepper_base* _dt_calc = nullptr;
};
#endif // wmsolver_h