ogs.cpp File Reference

Detailed Description

Implementation of OpenGeoSys simulation application.

Date

2014-08-04

Copyright

Copyright (c) 2012-2024, 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.cpp.

#include <algorithm>
#include <pybind11/pybind11.h>
#include <spdlog/spdlog.h>
#include <tclap/CmdLine.h>
#include <chrono>
#include <filesystem>
#include <sstream>
#include "CommandLineArgumentParser.h"
#include <cfenv>
#include "Applications/ApplicationsLib/Simulation.h"
#include "Applications/ApplicationsLib/TestDefinition.h"
#include "BaseLib/DateTools.h"
#include "BaseLib/Error.h"
#include "BaseLib/Logging.h"
#include "BaseLib/RunTime.h"
#include "InfoLib/GitInfo.h"

Include dependency graph for ogs.cpp:

Go to the source code of this file.

Functions
void	enableFloatingPointExceptions ()
int	main (int argc, char *argv[])

Function Documentation

enableFloatingPointExceptions()

void enableFloatingPointExceptions

(

)

Definition at line 44 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().

main()

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

Definition at line 56 of file ogs.cpp.

{
    CommandLineArguments cli_arg = parseCommandLineArguments(argc, argv);
    BaseLib::initOGSLogger(cli_arg.log_level);
#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}.",
         GitInfoLib::GitInfo::ogs_version);
 
    if (cli_arg.outdir.length() > 0)
    {
        std::error_code mkdir_err;
        if (std::filesystem::create_directories(cli_arg.outdir, mkdir_err))
        {
            INFO("Output directory {:s} created.", cli_arg.outdir);
        }
        else if (mkdir_err.value() != 0)
        {
            WARN(
                "Could not create output directory {:s}. Error code {:d}, {:s}",
                cli_arg.outdir, mkdir_err.value(), mkdir_err.message());
        }
    }
 
    {
        auto const start_time = std::chrono::system_clock::now();
        auto const time_str = BaseLib::formatDate(start_time);
        INFO("OGS started on {:s}.", time_str);
    }
 
    std::optional<ApplicationsLib::TestDefinition> test_definition{
        std::nullopt};
    auto ogs_status = EXIT_SUCCESS;
 
    try
    {
        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());
        }
 
        INFO("[time] Execution 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;
    }
 
    {
        auto const end_time = std::chrono::system_clock::now();
        auto const time_str = BaseLib::formatDate(end_time);
        INFO("OGS terminated on {:s}.", time_str);
    }
 
    if (ogs_status == EXIT_FAILURE)
    {
        ERR("OGS terminated with error.");
        return EXIT_FAILURE;
    }
 
    if (!test_definition)
    {
        // There are no tests, so just exit;
        return ogs_status;
    }
 
    INFO("");
    INFO("##########################################");
    INFO("# Running tests                          #");
    INFO("##########################################");
    INFO("");
    if (!test_definition->runTests())
    {
        ERR("One of the tests failed.");
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

References BaseLib::RunTime::elapsed(), CommandLineArguments::enable_fpe_is_set, enableFloatingPointExceptions(), ERR(), BaseLib::formatDate(), INFO(), BaseLib::initOGSLogger(), CommandLineArguments::log_level, CommandLineArguments::mesh_dir, CommandLineArguments::nonfatal, OGS_FATAL, GitInfoLib::GitInfo::ogs_version, CommandLineArguments::outdir, parseCommandLineArguments(), CommandLineArguments::project, CommandLineArguments::reference_path, CommandLineArguments::reference_path_is_set, CommandLineArguments::script_dir, simulation, BaseLib::RunTime::start(), WARN(), CommandLineArguments::write_prj, and CommandLineArguments::xml_patch_file_names.