ogs_python_module.cpp File Reference

Detailed Description

Implementation of OpenGeoSys simulation application python module.

Copyright

Copyright (c) 2012-2025, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

Definition in file ogs_python_module.cpp.

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <spdlog/spdlog.h>
#include <tclap/CmdLine.h>
#include <algorithm>
#include "../ogs.mesh/OGSMesh.h"
#include "Applications/ApplicationsLib/Simulation.h"
#include "Applications/ApplicationsLib/TestDefinition.h"
#include "BaseLib/DateTools.h"
#include "BaseLib/Error.h"
#include "BaseLib/FileTools.h"
#include "BaseLib/Logging.h"
#include "BaseLib/RunTime.h"
#include "CommandLineArgumentParser.h"
#include "InfoLib/GitInfo.h"
#include "ogs_embedded_python.h"

Include dependency graph for ogs_python_module.cpp:

Go to the source code of this file.

Functions
int	initOGS (std::vector< std::string > &argv_str)
int	executeSimulation ()
int	executeTimeStep ()
double	currentTime ()
double	endTime ()
OGSMesh	getMesh (std::string const &name)
void	finalize ()
	PYBIND11_MODULE (simulator, m)

Variables
std::unique_ptr< Simulation >	simulation
static constexpr int	EXIT_ARGPARSE_FAILURE = 3
static constexpr int	EXIT_ARGPARSE_EXIT_OK = 2

Function Documentation

currentTime()

double currentTime

(

)

Definition at line 177 of file ogs_python_module.cpp.

{
    return simulation->currentTime();
}

References simulation.

Referenced by PYBIND11_MODULE().

endTime()

double endTime

(

)

Definition at line 182 of file ogs_python_module.cpp.

{
    return simulation->endTime();
}

References simulation.

Referenced by PYBIND11_MODULE().

executeSimulation()

int executeSimulation

(

)

Definition at line 111 of file ogs_python_module.cpp.

{
    BaseLib::RunTime run_time;
 
    {
        auto const start_time = std::chrono::system_clock::now();
        auto const time_str = BaseLib::formatDate(start_time);
        INFO("OGS started on {:s} in serial mode.", time_str);
    }
 
    auto ogs_status = EXIT_SUCCESS;
    std::optional<ApplicationsLib::TestDefinition> test_definition{
        std::nullopt};
 
    try
    {
        run_time.start();
        bool solver_succeeded = simulation->executeSimulation();
        simulation->outputLastTimeStep();
        test_definition = simulation->getTestDefinition();
 
        if (solver_succeeded)
        {
            INFO("[time] Simulation completed. It took {:g} s.",
                 run_time.elapsed());
        }
        else
        {
            INFO("[time] Simulation failed. It took {:g} s.",
                 run_time.elapsed());
        }
        ogs_status = solver_succeeded ? EXIT_SUCCESS : EXIT_FAILURE;
    }
    catch (std::exception& e)
    {
        ERR("{}", e.what());
        ogs_status = EXIT_FAILURE;
    }
 
    if (ogs_status == EXIT_FAILURE)
    {
        auto const end_time = std::chrono::system_clock::now();
        auto const time_str = BaseLib::formatDate(end_time);
        ERR("OGS terminated with error on {:s}.", time_str);
        return EXIT_FAILURE;
    }
 
    return Simulation::runTestDefinitions(test_definition);
}

References BaseLib::RunTime::elapsed(), ERR(), BaseLib::formatDate(), INFO(), Simulation::runTestDefinitions(), simulation, and BaseLib::RunTime::start().

Referenced by PYBIND11_MODULE().

executeTimeStep()

int executeTimeStep

(

)

Definition at line 161 of file ogs_python_module.cpp.

{
    auto ogs_status = EXIT_SUCCESS;
    try
    {
        bool solver_succeeded = simulation->executeTimeStep();
        ogs_status = solver_succeeded ? EXIT_SUCCESS : EXIT_FAILURE;
    }
    catch (std::exception& e)
    {
        ERR("{}", e.what());
        ogs_status = EXIT_FAILURE;
    }
    return ogs_status;
}

References ERR(), and simulation.

Referenced by PYBIND11_MODULE().

finalize()

void finalize

(

)

Definition at line 192 of file ogs_python_module.cpp.

{
    simulation.reset(nullptr);
 
    // TODO don't use global project directory, shared among different OGS
    // instances.
    // Unset project dir to make multiple OGS runs in one Python session
    // possible.
    BaseLib::unsetProjectDirectory();
}

References simulation, and BaseLib::unsetProjectDirectory().

Referenced by NumLib::detail::calculateFluxCorrectedTransportPETSc(), and PYBIND11_MODULE().

getMesh()

OGSMesh getMesh

(

std::string const &

name

)

Definition at line 187 of file ogs_python_module.cpp.

{
    return OGSMesh(simulation->getMesh(name));
}

References simulation.

Referenced by MeshElementRemovalDialog::accept(), MeshView::convertMeshToGeometry(), MeshView::exportToShapefile(), MeshView::exportToTetGen(), MeshView::extractSurfaceMesh(), ProcessLib::AssemblyMixin< Process >::initializeAssemblyOnSubmeshes(), MeshElementRemovalDialog::on_boundingBoxCheckBox_toggled(), MeshView::openAddLayerDialog(), PYBIND11_MODULE(), and MeshView::writeToFile().

initOGS()

int initOGS

(

std::vector< std::string > &

argv_str

)

Definition at line 39 of file ogs_python_module.cpp.

{
    int argc = argv_str.size();
    char** argv = new char*[argc];
    for (int i = 0; i < argc; ++i)
    {
        argv[i] = argv_str[i].data();
    }
 
    CommandLineArguments cli_args;
    try
    {
        cli_args = parseCommandLineArguments(argc, argv, false);
    }
    catch (TCLAP::ArgException const& e)
    {
        ERR("Parsing the OGS commandline failed: {}", e.what());
 
        // "mangle" TCLAP's status
        return EXIT_ARGPARSE_FAILURE;
    }
    catch (TCLAP::ExitException const& e)
    {
        if (e.getExitStatus() == 0)
        {
            return EXIT_ARGPARSE_EXIT_OK;
        }
 
        // "mangle" TCLAP's status
        return EXIT_ARGPARSE_FAILURE;
    }
 
    BaseLib::initOGSLogger(cli_args.log_level);
 
    INFO(
        "This is OpenGeoSys-6 version {:s}. Log version: {:d}, Log level: "
        "{:s}.",
        GitInfoLib::GitInfo::ogs_version, 2, cli_args.log_level);
 
    BaseLib::createOutputDirectory(cli_args.outdir);
 
    {
        auto const start_time = std::chrono::system_clock::now();
        auto const time_str = BaseLib::formatDate(start_time);
        INFO("OGS started on {:s} in serial mode / Python embedded mode.",
             time_str);
    }
 
    auto ogs_status = EXIT_SUCCESS;
 
    try
    {
        simulation = std::make_unique<Simulation>(argc, argv);
        simulation->initializeDataStructures(
            std::move(cli_args.project),
            std::move(cli_args.xml_patch_file_names),
            cli_args.reference_path_is_set, std::move(cli_args.reference_path),
            cli_args.nonfatal, std::move(cli_args.outdir),
            std::move(cli_args.mesh_dir), std::move(cli_args.script_dir),
            cli_args.write_prj);
    }
    catch (std::exception& e)
    {
        ERR("{}", e.what());
        ogs_status = EXIT_FAILURE;
    }
 
    INFO("OpenGeoSys is now initialized.");
 
    return ogs_status;
}

References BaseLib::createOutputDirectory(), ERR(), EXIT_ARGPARSE_EXIT_OK, EXIT_ARGPARSE_FAILURE, BaseLib::formatDate(), INFO(), BaseLib::initOGSLogger(), CommandLineArguments::log_level, CommandLineArguments::mesh_dir, CommandLineArguments::nonfatal, GitInfoLib::GitInfo::ogs_version, CommandLineArguments::outdir, parseCommandLineArguments(), CommandLineArguments::project, CommandLineArguments::reference_path, CommandLineArguments::reference_path_is_set, CommandLineArguments::script_dir, simulation, CommandLineArguments::write_prj, and CommandLineArguments::xml_patch_file_names.

Referenced by PYBIND11_MODULE().

PYBIND11_MODULE()

PYBIND11_MODULE	(	simulator	,
		m	)

To use this module import dependencies first: import ogs.mesh as mesh import ogs.simulator as sim

See also https://github.com/pybind/pybind11/issues/1391#issuecomment-912642979

Definition at line 209 of file ogs_python_module.cpp.

{
    m.attr("__name__") = "ogs.simulator";
    m.doc() = "pybind11 ogs example plugin";
    m.def("initialize", &initOGS, "init OGS");
    m.def("currentTime", &currentTime, "get current OGS time");
    m.def("endTime", &endTime, "get end OGS time");
    m.def("executeSimulation", &executeSimulation, "execute OGS simulation");
    m.def("executeTimeStep", &executeTimeStep, "execute OGS time step");
    m.def("getMesh", &getMesh, "get unstructured grid from ogs");
    m.def("finalize", &finalize, "finalize OGS simulation");
}

References currentTime(), endTime(), executeSimulation(), executeTimeStep(), finalize(), getMesh(), and initOGS().

Variable Documentation

EXIT_ARGPARSE_EXIT_OK

int EXIT_ARGPARSE_EXIT_OK = 2

staticconstexpr

Definition at line 35 of file ogs_python_module.cpp.

Referenced by initOGS().

EXIT_ARGPARSE_FAILURE

int EXIT_ARGPARSE_FAILURE = 3

staticconstexpr

Definition at line 34 of file ogs_python_module.cpp.

Referenced by initOGS().

simulation

std::unique_ptr<Simulation> simulation

Definition at line 32 of file ogs_python_module.cpp.

Referenced by currentTime(), endTime(), executeSimulation(), executeTimeStep(), finalize(), getMesh(), initOGS(), and main().