wmtemporalsolver.h

Go to the documentation of this file.

#ifndef WM_TEMPORALSOLVER_H
#define WM_TEMPORALSOLVER_H
 
#include "sync/synchronizer.h"
#include "wmhostaction.h"
 
#include <memory>
#include <vector>
#include <array>
#include <numeric>
 
namespace wxm
{
namespace variable
{
class distributed_variable_t;
}
namespace dfem
{
namespace variable_adjuster
{
class variable_adjuster_t;
}
namespace solver
{
class spatial_solver_t;
}
} // namespace dfem
 
class temporal_solver : public WmHostAction
{
    // all spatial operators/variable adjusters are patch processes
    std::vector<std::unique_ptr<WmHostAction>> processors_;
 
    bool add_variables(const WxCryptSet& wxc, const std::string& name);
 
    // all local patch synchronizers
    std::vector<std::vector<std::unique_ptr<wxm::sync::patch_synchronizer_t>>>
        synchronizers_;
 
public:
    // pair of variable/component
    typedef std::vector<std::pair<wxm::variable::distributed_variable_t*, size_t>>
        variables_type;
 
    struct temporal_var
    {
        size_t index;
        const WmUnstructuredPatch* patch;
        // full range
        const WxRange* range;
        size_t num_dof;
 
        temporal_var(size_t index,
                     const WmUnstructuredPatch* patch,
                     const WxRange* full,
                     size_t num_dof)
            : index(index), patch(patch), range(full), num_dof(num_dof)
        {
        }
    };
 
    const std::vector<wxm::dfem::variable_adjuster::variable_adjuster_t*>&
    getVariableAdjusters() const
    {
        return adjusters_;
    }
 
    std::vector<variables_type>& getVariables()
    {
        return variables_;
    }
 
protected:
    // variable adjusters to be run, in sorted order
    std::vector<wxm::dfem::variable_adjuster::variable_adjuster_t*> adjusters_;
 
    // priorities of the various variable adjusters
    std::vector<int> va_priorities;
 
    int min_priority;
    // maximum number of variable adjuster priority levels
    int max_priority;
 
    // spatial solvers to run
    std::vector<wxm::dfem::solver::spatial_solver_t*> spatial_solvers_;
 
    // pair of distributed variable and component index
    std::vector<variables_type> variables_;
 
    // indices of variables which change in time
    std::vector<temporal_var> temporal_vars_;
 
public:
    temporal_solver(const WmConstOpaquePtr& parent_solver) : WmHostAction(parent_solver)
    {
    }
 
    void setup(const WxCryptSet& wxc) override;
 
    bool needsDomain() const override
    {
        return false;
    }
 
    void start_sync(size_t i);
 
    void finish_sync(size_t i);
 
    void fill_local(size_t i, real val = 0);
 
protected:
    void typeCheck() override;
};
} // namespace wxm
 
#endif