Ideas: LUA (-> JSON)->C++

[anaegel]

How can we replace exisiting LUA code (e.g. from *_util.lua) efficiently?

Packages:

• https://github.com/UG4/ugcore
• https://github.com/UG4/JSONToolkit
• https://github.com/UG4/plugin_Util

Goal:

Want to mimick classic LUA setup:

local luaobject = CreateObject({property1=2, property2="Hello"})

[anaegel]

Realized a draft for enriching the registry by "Builders". Similar to factories, these allow to create objects:

https://github.com/UG4/JSONToolkit/blob/main/test/test-builders.lua

Realized in branch: feature-json-schema.

Option 1: Construct C++ Object (with JSON defaults)

local builder = JacobiBuilderCPU1()
desc1 = builder:get_default() -- returns description of default config
print(desc1) 

Option 2: LUA table => JSON object => C++ Object

local jdesc=JSON()
JSON_parse(jdesc2, util.json.encode({damp=0.75, bBlock=true}))
local jac=JacobiBuilderCPU1(jdesc):build()            
print(jac:config_string())

Pros:

• JSON schema defined in C++ code
• Validation available

Cons:

• Must interact with registry
• Requires various type_traits.

[anaegel]

For the builders, we require defining certain type_traits:

Trait for obtaining a defaults:

template <typename T>
struct json_default { static const nlohmann::json value; };

Trait for obtaining a schema:

template <typename T>
struct json_schema{ static constexpr const char* value;};

Trait for constructing objects from JSON.

template <typename T>
struct json_assignment
{
	static void from_json(const nlohmann::json& j, T& obj);
	
};

[einfisch]

#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
#include <variant>
#include <stdexcept>

// Forward declarations for various components
class ApproximationSpace;
class ILU;
class ILUT;
class Jacobi;
class BlockGaussSeidel;
class GaussSeidel;
class SymmetricGaussSeidel;
class ElementGaussSeidel;
class ComponentGaussSeidel;
class SequentialSubspaceCorrection;
class GeometricMultiGrid;
class SchurComplement;
class LinearSolver;
class Transfer;
class MGStats;
class DebugWriter;

// Variant type for storing different components
using SolverComponent = std::variant<
    std::shared_ptr<ApproximationSpace>,
    std::shared_ptr<ILU>,
    std::shared_ptr<ILUT>,
    std::shared_ptr<Jacobi>,
    std::shared_ptr<BlockGaussSeidel>,
    std::shared_ptr<GaussSeidel>,
    std::shared_ptr<SymmetricGaussSeidel>,
    std::shared_ptr<ElementGaussSeidel>,
    std::shared_ptr<ComponentGaussSeidel>,
    std::shared_ptr<SequentialSubspaceCorrection>,
    std::shared_ptr<GeometricMultiGrid>,
    std::shared_ptr<SchurComplement>,
    std::shared_ptr<LinearSolver>,
    std::shared_ptr<Transfer>,
    std::shared_ptr<MGStats>,
    std::shared_ptr<DebugWriter>
>;

class SolverUtil {
public:
    void setComponent(const std::string& key, SolverComponent component) {
        components[key] = component;
    }

    SolverComponent getComponent(const std::string& key) const {
        auto it = components.find(key);
        if (it != components.end()) {
            return it->second;
        }
        throw std::runtime_error("Component not found: " + key);
    }

    template <typename T>
    std::shared_ptr<T> getComponentAs(const std::string& key) const {
        return std::get<std::shared_ptr<T>>(getComponent(key));
    }

    void printComponents() const {
        for (const auto& [key, value] : components) {
            std::cout << key << std::endl;
        }
    }

private:
    std::unordered_map<std::string, SolverComponent> components;
};

// Placeholder classes for various solver components
class ApproximationSpace {};
class ILU {
public:
    void set_beta(double beta) {}
    void set_damp(double damping) {}
    void set_sort(bool sort) {}
    void set_ordering_algorithm(std::shared_ptr<void> ordering) {}
    void set_sort_eps(double sortEps) {}
    void set_inversion_eps(double inversionEps) {}
    void enable_consistent_interfaces(bool consistentInterfaces) {}
    void enable_overlap(bool overlap) {}
};
class ILUT {
public:
    ILUT(double threshold) {}
    void set_ordering_algorithm(std::shared_ptr<void> ordering) {}
};
class Jacobi {
public:
    Jacobi(double damping) {}
};
class BlockGaussSeidel {};
class GaussSeidel {
public:
    void enable_consistent_interfaces(bool consistentInterfaces) {}
    void enable_overlap(bool overlap) {}
};
class SymmetricGaussSeidel {
public:
    void enable_consistent_interfaces(bool consistentInterfaces) {}
    void enable_overlap(bool overlap) {}
};
class ElementGaussSeidel {};
class ComponentGaussSeidel {};
class SequentialSubspaceCorrection {
public:
    SequentialSubspaceCorrection(double damping) {}
    void set_vertex_subspace(std::shared_ptr<void> vertexSubspace) {}
};
class GeometricMultiGrid {
public:
    GeometricMultiGrid(std::shared_ptr<ApproximationSpace> approxSpace) {}
    void set_base_solver(std::shared_ptr<LinearSolver> baseSolver) {}
    void set_smoother(std::shared_ptr<void> smoother) {}
    void set_base_level(int baseLevel) {}
    void set_cycle_type(const std::string& cycle) {}
    void set_num_presmooth(int preSmooth) {}
    void set_num_postsmooth(int postSmooth) {}
    void set_rap(bool rap) {}
    void set_smooth_on_surface_rim(bool rim) {}
    void set_emulate_full_refined_grid(bool emulateFullRefined) {}
    void set_gathered_base_solver_if_ambiguous(bool gatheredBaseSolverIfAmbiguous) {}
    void set_transfer(std::shared_ptr<Transfer> transfer) {}
    void set_discretization(const std::string& discretization) {}
    void set_mg_stats(std::shared_ptr<MGStats> mgStats) {}
    void set_debug(std::shared_ptr<DebugWriter> debugWriter) {}
    void set_surface_level(int surfaceLevel) {}
};
class SchurComplement {
public:
    void set_dirichlet_solver(std::shared_ptr<LinearSolver> dirichletSolver) {}
    void set_skeleton_solver(std::shared_ptr<void> skeletonSolver) {}
};
class LinearSolver {};
class Transfer {};
class MGStats {};
class DebugWriter {
public:
    DebugWriter(std::shared_ptr<ApproximationSpace> approxSpace) {}
    void set_vtk_output(bool vtkOutput) {}
    void set_conn_viewer_output(bool connViewerOutput) {}
};
class GridFunction {
public:
    GridFunction(std::shared_ptr<ApproximationSpace> approxSpace) {}
};
class DebugIterator {
public:
    DebugIterator(std::shared_ptr<void> precond, std::shared_ptr<LinearSolver> dsolver) {}
    void set_solution(std::shared_ptr<GridFunction> err) {}
};

// Functions that need to be implemented
std::shared_ptr<void> CreateOrdering(const std::string& ordering, const SolverUtil& solverutil) {
    // Implementation goes here
    return nullptr;
}

std::shared_ptr<LinearSolver> CreateLinearSolver(const std::string& solverDesc, const SolverUtil& solverutil) {
    // Implementation goes here
    return std::make_shared<LinearSolver>();
}

std::shared_ptr<Transfer> CreateTransfer(const std::string& transferDesc, const SolverUtil& solverutil) {
    // Implementation goes here
    return std::make_shared<Transfer>();
}

std::shared_ptr<MGStats> CreateMGStats(const std::string& mgStatsDesc) {
    // Implementation goes here
    return std::make_shared<MGStats>();
}

std::shared_ptr<void> CreatePreconditioner(const std::string& precondDesc, SolverUtil& solverutil) {
    std::string name = precondDesc;  // For simplicity, assuming precondDesc is just the name
    std::shared_ptr<void> precond = nullptr;
    auto approxSpace = solverutil.getComponentAs<ApproximationSpace>("approxSpace");

    if (name == "ilu") {
        auto ilu = std::make_shared<ILU>();
        // Set properties for ilu
        precond = ilu;
    } else if (name == "ilut") {
        auto ilut = std::make_shared<ILUT>(0.0);  // Assuming default threshold is 0.0
        // Set properties for ilut
        precond = ilut;
    } else if (name == "jac") {
        auto jacobi = std::make_shared<Jacobi>(1.0);  // Assuming default damping is 1.0
        precond = jacobi;
    } else if (name == "bgs") {
        precond = std::make_shared<BlockGaussSeidel>();
    } else if (name == "gs") {
        auto gs = std::make_shared<GaussSeidel>();
        // Set properties for gs
        precond = gs;
    } else if (name == "sgs") {
        auto sgs = std::make_shared<SymmetricGaussSeidel>();
        // Set properties for sgs
        precond = sgs;
    } else if (name == "egs") {
        precond = std::make_shared<ElementGaussSeidel>();
    } else if (name == "cgs") {
        precond = std::make_shared<ComponentGaussSeidel>();
    } else if (name == "ssc") {
        auto ssc = std::make_shared<SequentialSubspaceCorrection>(1.0);  // Assuming default damping is 1.0
        // Set properties for ssc
        precond = ssc;
    } else if (name == "gmg") {
        auto smoother = CreatePreconditioner("smoother", solverutil);
        auto baseSolver = CreateLinearSolver("baseSolver", solverutil);

        if (!approxSpace) {
            std::cerr << "An ApproximationSpace is required to create a 'gmg' solver.\n";
            std::exit(1);
        }

        auto gmg = std::make_shared<GeometricMultiGrid>(approxSpace);
        gmg->set_base_solver(std::dynamic_pointer_cast<LinearSolver>(baseSolver));
        gmg->set_smoother(smoother);
        gmg->set_base_level(0);  // Assuming default base level is 0
        gmg->set_cycle_type("V");  // Assuming default cycle type is "V"
        gmg->set_num_presmooth(2);  // Assuming default pre-smooth is 2
        gmg->set_num_postsmooth(2);  // Assuming default post-smooth is 2
        gmg->set_rap(false);  // Assuming default RAP is false
        gmg->set_smooth_on_surface_rim(false);  // Assuming default rim is false
        gmg->set_emulate_full_refined_grid(false);  // Assuming default emulation is false
        gmg->set_gathered_base_solver_if_ambiguous(false);  // Assuming default gathered base solver if ambiguous is false

        auto transfer = CreateTransfer("transfer", solverutil);
        gmg->set_transfer(transfer);
        
        gmg->set_discretization("discretization");  // Assuming default discretization

        auto mgStats = CreateMGStats("mgStats");
        gmg->set_mg_stats(mgStats);

        auto debugWriter = std::make_shared<DebugWriter>(approxSpace);
        debugWriter->set_vtk_output(false);  // Assuming default VTK output is false
        debugWriter->set_conn_viewer_output(false);  // Assuming default Conn Viewer output is false
        gmg->set_debug(debugWriter);

        gmg->set_surface_level(0);  // Assuming default surface level is 0

        precond = gmg;
    } else if (name == "schur") {
        auto dirichletSolver = CreateLinearSolver("dirichletSolver", solverutil);
        auto skeletonSolver = CreateLinearSolver("skeletonSolver", solverutil);

        auto schur = std::make_shared<SchurComplement>();
        schur->set_dirichlet_solver(dirichletSolver);
        schur->set_skeleton_solver(skeletonSolver);
        precond = schur;
    }

    if (!precond) {
        throw std::runtime_error("Failed to create preconditioner: " + precondDesc);
    }

    return precond;
}