solver.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program 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, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__SOLVER_H
#define PLASK__SOLVER_H
 
#include <string>
 
#include "log/log.hpp"
#include "log/data.hpp"
#include "mesh/mesh.hpp"
#include "geometry/space.hpp"
#include "geometry/reader.hpp"
#include "manager.hpp"
 
namespace plask {
 
struct Manager;
 
class PLASK_API Solver {
 
    std::string solver_name;
 
  protected:
 
    bool initialized;
 
    virtual void onInitialize() {}
 
    virtual void onInvalidate() {}
 
  public:
 
    bool initCalculation();
 
    Solver(const std::string& name=""): solver_name(name), initialized(false) {}
 
    virtual ~Solver() {}
 
    virtual void loadConfiguration(XMLReader& source, Manager& manager);
 
    void parseStandardConfiguration(XMLReader& source, Manager& manager, const std::string& expected_msg="solver configuration element");
 
    bool isInitialized() { return initialized; }
 
    void invalidate() {
        if (initialized) {
            initialized = false;
            writelog(LOG_INFO, "Invalidating solver");
            onInvalidate();
        }
    }
 
    virtual std::string getClassName() const = 0;
 
    inline std::string getId() const {
        std::string name = "";
        if (solver_name != "") {
            name += solver_name; name += ":";
        }
        return name + getClassName();
    }
 
    inline std::string getName() const { return solver_name; }
 
    virtual std::string getClassDescription() const { return ""; }
 
    template<typename ArgT = double, typename ValT = double>
    DataLog<ArgT, ValT> dataLog(const std::string& chart_name, const std::string& axis_arg_name, const std::string& axis_val_name) {
        return DataLog<ArgT, ValT>(getId(), chart_name, axis_arg_name, axis_val_name);
    }
 
 
    template<typename ArgT = double, typename ValT = double>
    DataLog<ArgT, ValT> dataLog(const std::string& axis_arg_name, const std::string& axis_val_name) {
        return DataLog<ArgT, ValT>(getId(), axis_arg_name, axis_val_name);
    }
 
    template<typename ...Args>
    void writelog(LogLevel level, std::string msg, Args&&... params) const { plask::writelog(level, getId() + ": " + msg, std::forward<Args>(params)...); }
 
    //virtual shared_ptr<const Geometry> getUsedGeometry() const;   //return empty by default
    //virtual shared_ptr<const Mesh> getUsedMesh() const;
 
};
 
/*
 * Function constructing solver on library loadConfiguration
 */
#define SOLVER_CONSTRUCT_FUNCTION_SUFFIX "_solver_factory"
extern "C" typedef Solver* solver_construct_f(const std::string& name);
 
 
template <typename, typename> struct SolverWithMesh;
 
template <typename SpaceT>
class SolverOver: public Solver {
 
    void diconnectGeometry() {
        if (this->geometry)
            this->geometry->changedDisconnectMethod(this, &SolverOver<SpaceT>::onGeometryChange);
    }
 
  protected:
 
    shared_ptr<SpaceT> geometry;
 
    template <typename Boundary, typename ConditionT>
    void readBoundaryConditions(Manager& manager, XMLReader& reader, BoundaryConditions<Boundary, ConditionT>& dest) {
        manager.readBoundaryConditions<Boundary, ConditionT>(reader, dest);
    }
 
  public:
 
    typedef SpaceT SpaceType;
 
    SolverOver(const std::string& name="") : Solver(name) {}
 
    ~SolverOver() {
        diconnectGeometry();
    }
 
    void loadConfiguration(XMLReader& source, Manager& manager) override;
 
    void parseStandardConfiguration(XMLReader& source, Manager& manager, const std::string& expected_msg="solver configuration element");
 
    virtual void onGeometryChange(const Geometry::Event&) {
        this->invalidate();
    }
 
    inline shared_ptr<SpaceT> getGeometry() const { return geometry; }
 
    void setGeometry(const shared_ptr<SpaceT>& geometry) {
        if (geometry == this->geometry) return;
        writelog(LOG_INFO, "Attaching geometry to solver");
        diconnectGeometry();
        this->geometry = geometry;
        if (this->geometry)
            this->geometry->changedConnectMethod(this, &SolverOver<SpaceT>::onGeometryChange);
        onGeometryChange(Geometry::Event(geometry.get(), 0));
    }
};
 
template <typename SpaceT, typename MeshT>
struct SolverWithMesh: public SolverOver<SpaceT> {
 
    typedef MeshT MeshType;
 
private:
 
    shared_ptr<MeshGeneratorD<MeshT::DIM>> mesh_generator;
 
    void disconnectMesh() {
        /*if (this->mesh)
            this->mesh->changedDisconnectMethod(this, &SolverWithMesh<SpaceT, MeshT>::onMeshChange);*/
        mesh_signal_connection.disconnect();
    }
 
    void clearGenerator() {
        if (this->mesh_generator)
            this->mesh_generator->changedDisconnectMethod(this, &SolverWithMesh<SpaceT, MeshT>::onGeneratorChange);
        mesh_generator.reset();
    }
 
    void regenerateMesh() {
        if (this->mesh_generator && this->geometry) {
            auto mesh = mesh_generator->template get<MeshType>(this->geometry->getChild());
            if (mesh == this->mesh) return;
            disconnectMesh();
            this->mesh = mesh;
            if (this->mesh)
                mesh_signal_connection = this->mesh->changedConnectMethod(this, &SolverWithMesh<SpaceT, MeshT>::onMeshChange);
            onMeshChange(typename MeshT::Event(mesh.get(), 0));
        }
    }
 
    void onGeneratorChange(const typename MeshGenerator::Event&) {
        regenerateMesh();
    }
 
  protected:
 
    shared_ptr<MeshT> mesh;
 
    boost::signals2::connection mesh_signal_connection;
 
  public:
 
    SolverWithMesh(const std::string& name="") : SolverOver<SpaceT>(name) {}
 
    ~SolverWithMesh() {
        disconnectMesh();
        clearGenerator();
    }
 
    void loadConfiguration(XMLReader& source, Manager& manager) override;
 
    void parseStandardConfiguration(XMLReader& source, Manager& manager, const std::string& expected_msg="solver configuration element");
 
    virtual void onMeshChange(const typename MeshT::Event& PLASK_UNUSED(evt)) {
        this->invalidate();
    }
 
    void onGeometryChange(const Geometry::Event& PLASK_UNUSED(evt)) override {
        this->invalidate();
        this->regenerateMesh();
    }
 
    inline MeshT& meshRef() const { return *mesh; }
 
    inline shared_ptr<MeshT> getMesh() const { return mesh; }
 
    void setMesh(const shared_ptr<MeshT>& mesh) {
        clearGenerator();
        if (mesh == this->mesh) return;
        this->writelog(LOG_INFO, "Attaching mesh to solver");
        disconnectMesh();
        this->mesh = mesh;
        if (this->mesh)
            mesh_signal_connection = this->mesh->changedConnectMethod(this, &SolverWithMesh<SpaceT, MeshT>::onMeshChange);
        onMeshChange(typename MeshT::Event(mesh.get(), 0));
    }
 
    void setMesh(shared_ptr<MeshGeneratorD<MeshT::DIM>> generator) {
        clearGenerator();
        this->writelog(LOG_INFO, "Attaching mesh generator to solver");
        mesh_generator = generator;
        if (mesh_generator)
            mesh_generator->changedConnectMethod(this, &SolverWithMesh<SpaceT, MeshT>::onGeneratorChange);
        regenerateMesh();
    }
};
 
}       //namespace plask
 
#include "manager.hpp" // Just in case module author includes only "solver.hpp"
 
namespace plask {
 
template <typename SpaceT>
void SolverOver<SpaceT>::loadConfiguration(XMLReader& reader, Manager& manager) {
        while (reader.requireTagOrEnd()) parseStandardConfiguration(reader, manager, "<geometry>");
}
 
template <typename SpaceT, typename MeshT>
void SolverWithMesh<SpaceT, MeshT>::loadConfiguration(XMLReader& reader, Manager& manager) {
        while (reader.requireTagOrEnd()) parseStandardConfiguration(reader, manager, "<geometry> or <mesh>");
}
 
 
template <typename SpaceT>
void SolverOver<SpaceT>::parseStandardConfiguration(XMLReader& reader, Manager& manager, const std::string& expected_msg) {
    if (reader.getNodeName() == "geometry") {
        auto name = reader.getAttribute("ref");
        if (!name) name.reset(reader.requireTextInCurrentTag());
        else reader.requireTagEnd();
        auto found = manager.geometrics.find(*name);
        if (found == manager.geometrics.end())
            throw BadInput(this->getId(), "geometry '{0}' not found", *name);
        else {
            auto geometry = dynamic_pointer_cast<SpaceT>(found->second);
            if (!geometry) throw BadInput(this->getId(), "geometry '{0}' of wrong type", *name);
            this->setGeometry(geometry);
        }
    } else {
        Solver::parseStandardConfiguration(reader, manager, expected_msg);
    }
}
 
template <typename SpaceT, typename MeshT>
void SolverWithMesh<SpaceT, MeshT>::parseStandardConfiguration(XMLReader& reader, Manager& manager, const std::string& expected_msg) {
    if (reader.getNodeName() == "mesh") {
        auto name = reader.getAttribute("ref");
        if (!name) name.reset(reader.requireTextInCurrentTag());
        else reader.requireTagEnd();
        auto found = manager.meshes.find(*name);
        if (found != manager.meshes.end()) {
            if (shared_ptr<MeshT> mesh = dynamic_pointer_cast<MeshT>(found->second)) {
                this->setMesh(mesh);
            } else {
                auto generator = dynamic_pointer_cast<MeshGeneratorD<MeshT::DIM>>(found->second);
                if (!generator) throw BadInput(this->getId(), "mesh or generator '{0}' of wrong type", *name);
                this->setMesh(generator);
            }
        }
    } else {
        SolverOver<SpaceT>::parseStandardConfiguration(reader, manager, expected_msg);
    }
}
 
}   // namespace plask
 
#endif // PLASK__SOLVER_H