ogs.cpp File Reference

#include <pybind11/embed.h>
#include <pybind11/pybind11.h>
#include <spdlog/spdlog.h>
#include <tclap/CmdLine.h>
#include <algorithm>
#include <chrono>
#include <csignal>
#include <iostream>
#include <sstream>
#include "Applications/CLI/ogs_embedded_python.h"
#include "CommandLineArgumentParser.h"
#include <cfenv>
#include "Applications/ApplicationsLib/Simulation.h"
#include "Applications/ApplicationsLib/TestDefinition.h"
#include "BaseLib/ConfigTree.h"
#include "BaseLib/DateTools.h"
#include "BaseLib/Error.h"
#include "BaseLib/FileTools.h"
#include "BaseLib/Logging.h"
#include "BaseLib/RunTime.h"
#include "InfoLib/GitInfo.h"
#include <spdlog/sinks/null_sink.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include "BaseLib/MPI.h"

Include dependency graph for ogs.cpp:

Go to the source code of this file.

Functions
void	enableFloatingPointExceptions ()
void	signalHandler (int signum)
void	initializeLogger (bool const all_ranks_log)
int	main (int argc, char *argv[])

Function Documentation

enableFloatingPointExceptions()

void enableFloatingPointExceptions

(

)

Definition at line 39 of file ogs.cpp.

{
#ifdef __APPLE__
#ifdef __SSE__
    _MM_SET_EXCEPTION_MASK(_MM_GET_EXCEPTION_MASK() & ~_MM_MASK_INVALID);
#endif  // __SSE__
#else
    feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
#endif  // __APPLE__
}

Referenced by main().

initializeLogger()

void initializeLogger

(

bool const

all_ranks_log

)

Definition at line 65 of file ogs.cpp.

{
#if defined(USE_PETSC)
    int mpi_rank;
    MPI_Comm_rank(BaseLib::MPI::OGS_COMM_WORLD, &mpi_rank);
    int world_size;
    MPI_Comm_size(BaseLib::MPI::OGS_COMM_WORLD, &world_size);
 
    if (all_ranks_log)
    {
        if (world_size > 1)
        {
            spdlog::set_pattern(fmt::format("[{}] %^%l:%$ %v", mpi_rank));
        }
        // else untouched
    }
    else  // only rank 0 logs
    {
        // set_pattern is untouched
        spdlog::drop_all();
        if (mpi_rank > 0)
        {
            BaseLib::console = spdlog::create<spdlog::sinks::null_sink_st>(
                "ogs");  // do not log
        }
        else  // rank 0
        {
            auto console = BaseLib::console =
                spdlog::stdout_color_st("ogs");  // st for performance
        }
    }
 
    {
        auto const start_time = std::chrono::system_clock::now();
        auto const time_str = BaseLib::formatDate(start_time);
        INFO("OGS started on {:s} with MPI. MPI processes: {:d}.", time_str,
             world_size);
    }
 
#else  // defined(USE_PETSC)
 
    {
        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);
    }
 
#endif
}

References BaseLib::console, BaseLib::formatDate(), INFO(), and BaseLib::MPI::OGS_COMM_WORLD.

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 115 of file ogs.cpp.

{
    CommandLineArguments cli_arg = parseCommandLineArguments(argc, argv);
 
    // Initialize MPI
    // also in python hook
    // check tools
    BaseLib::MPI::Setup mpi_setup(argc, argv);
    BaseLib::initOGSLogger(cli_arg.log_level);
    initializeLogger(cli_arg.log_parallel);
 
    signal(SIGINT, signalHandler);   // CTRL+C
    signal(SIGTERM, signalHandler);  // pkill -SIGTERM <process_id> , It is NOT
                                     // possible to catch SIGKILL
 
#ifndef _WIN32  // TODO: On windows floating point exceptions are not handled
    if (cli_arg.enable_fpe_is_set)
    {
        enableFloatingPointExceptions();
    }
#endif  // _WIN32
 
    INFO(
        "This is OpenGeoSys-6 version {:s}. Log version: {:d}, Log level: "
        "{:s}.",
        GitInfoLib::GitInfo::ogs_version, 2, cli_arg.log_level);
    BaseLib::createOutputDirectory(cli_arg.outdir);
 
    std::optional<ApplicationsLib::TestDefinition> test_definition{
        std::nullopt};
    auto ogs_status = EXIT_SUCCESS;
 
    try
    {
        pybind11::scoped_interpreter py_interpreter{
            ApplicationsLib::setupEmbeddedPython()};
        ApplicationsLib::setupEmbeddedPythonVenvPaths();
 
        Simulation simulation(argc, argv);
 
        BaseLib::RunTime run_time;
        run_time.start();
 
        bool solver_succeeded = false;
        try
        {
            simulation.initializeDataStructures(
                std::move(cli_arg.project),
                std::move(cli_arg.xml_patch_file_names),
                cli_arg.reference_path_is_set,
                std::move(cli_arg.reference_path), cli_arg.nonfatal,
                std::move(cli_arg.outdir), std::move(cli_arg.mesh_dir),
                std::move(cli_arg.script_dir), cli_arg.write_prj);
            solver_succeeded = simulation.executeSimulation();
            simulation.outputLastTimeStep();
            test_definition = simulation.getTestDefinition();
        }
        catch (pybind11::error_already_set const& e)
        {
            OGS_FATAL("Python exception thrown: {}", e.what());
        }
        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;
    }
 
    // Check for swallowed ConfigTree errors after Simulation destructor runs.
    // This catches configuration errors in objects destroyed at end of scope.
    try
    {
        BaseLib::ConfigTree::assertNoSwallowedErrors();
    }
    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::ConfigTree::assertNoSwallowedErrors(), BaseLib::createOutputDirectory(), BaseLib::RunTime::elapsed(), CommandLineArguments::enable_fpe_is_set, enableFloatingPointExceptions(), ERR(), Simulation::executeSimulation(), BaseLib::formatDate(), Simulation::getTestDefinition(), INFO(), Simulation::initializeDataStructures(), initializeLogger(), BaseLib::initOGSLogger(), CommandLineArguments::log_level, CommandLineArguments::log_parallel, CommandLineArguments::mesh_dir, CommandLineArguments::nonfatal, OGS_FATAL, GitInfoLib::GitInfo::ogs_version, CommandLineArguments::outdir, Simulation::outputLastTimeStep(), parseCommandLineArguments(), CommandLineArguments::project, CommandLineArguments::reference_path, CommandLineArguments::reference_path_is_set, Simulation::runTestDefinitions(), CommandLineArguments::script_dir, ApplicationsLib::setupEmbeddedPython(), ApplicationsLib::setupEmbeddedPythonVenvPaths(), signalHandler(), BaseLib::RunTime::start(), CommandLineArguments::write_prj, and CommandLineArguments::xml_patch_file_names.

signalHandler()

void signalHandler

(

int

signum

)

Definition at line 56 of file ogs.cpp.

{
    auto const end_time = std::chrono::system_clock::now();
    auto const time_str = BaseLib::formatDate(end_time);
 
    ERR("Simulation aborted on {:s}. Received signal: {:d}.", time_str, signum);
    exit(signum);
}

References ERR(), and BaseLib::formatDate().