OGSSimulation Class Reference

Detailed Description

Definition at line 51 of file ogs_python_module.cpp.

Public Member Functions
	OGSSimulation (std::vector< std::string > &argv_str)
int	executeSimulation ()
int	executeTimeStep ()
double	currentTime () const
double	endTime () const
OGSMesh &	getMesh (std::string const &name)
std::vector< std::string >	getMeshNames () const
int	finalize ()
int	status () const
bool	initialized () const

Private Attributes
int	ogs_status = EXIT_SUCCESS
std::unique_ptr< Simulation >	simulation
std::optional< ApplicationsLib::TestDefinition >	test_definition
bool	test_definition_pending = false
std::map< std::string, OGSMesh >	mesh_mapping
std::optional< BaseLib::MPI::Setup >	mpi_setup

Constructor & Destructor Documentation

OGSSimulation()

OGSSimulation::OGSSimulation ( std::vector< std::string > & argv_str )

inlineexplicit

Definition at line 54 of file ogs_python_module.cpp.

    {
        auto [argc, argv_vec] = toArgcArgv(argv_str);
        char** argv = argv_vec.data();
 
        mpi_setup.emplace(argc, argv);
 
        CommandLineArguments cli_args;
        try
        {
            cli_args = parseCommandLineArguments(argc, argv, false);
        }
        catch (TCLAP::ArgException const& e)
        {
            // TODO fragile interplay between (incomplete) simulation
            // initialization and OGS logger initialization
            BaseLib::initOGSLogger(BaseLib::defaultLogLevel());
 
            std::cerr << "Parsing the OGS commandline failed: " << e.what()
                      << '\n';
 
            // "mangle" TCLAP's status
            throw(e);
        }
        catch (TCLAP::ExitException const& e)
        {
            // TODO fragile interplay between (incomplete) simulation
            // initialization and OGS logger initialization
            BaseLib::initOGSLogger(BaseLib::defaultLogLevel());
 
            if (e.getExitStatus() == 0)
            {
                // --version/--help
                return;
            }
 
            throw(e);
        }
 
        BaseLib::initOGSLogger(cli_args.log_level);
 
        DBUG("OGSSimulation::OGSSimulation(std::vector<std::string>&)");
 
        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);
            // todo ask Tobias: started vs starts
#ifdef USE_PETSC
            int size;
            MPI_Comm_size(BaseLib::MPI::OGS_COMM_WORLD, &size);
            int rank;
            MPI_Comm_rank(BaseLib::MPI::OGS_COMM_WORLD, &rank);
            INFO(
                "OGS starts on {:s} in MPI mode [{}] of {} / Python embedded "
                "mode.",
                time_str, rank, size);
#else
            INFO("OGS starts on {:s} in serial mode / Python embedded mode.",
                 time_str);
#endif
        }
        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;
            simulation.reset();
            throw(e);
        }
        INFO("OpenGeoSys is now initialized.");
    }

References BaseLib::createOutputDirectory(), DBUG(), BaseLib::defaultLogLevel(), ERR(), BaseLib::formatDate(), INFO(), BaseLib::initOGSLogger(), CommandLineArguments::log_level, CommandLineArguments::mesh_dir, mpi_setup, CommandLineArguments::nonfatal, BaseLib::MPI::OGS_COMM_WORLD, ogs_status, GitInfoLib::GitInfo::ogs_version, CommandLineArguments::outdir, parseCommandLineArguments(), CommandLineArguments::project, CommandLineArguments::reference_path, CommandLineArguments::reference_path_is_set, CommandLineArguments::script_dir, simulation, toArgcArgv(), CommandLineArguments::write_prj, and CommandLineArguments::xml_patch_file_names.

Member Function Documentation

currentTime()

double OGSSimulation::currentTime ( ) const

inline

Definition at line 209 of file ogs_python_module.cpp.

    {
        OGS_ALWAYS_ASSERT(initialized());
        return simulation->currentTime();
    }

References initialized(), OGS_ALWAYS_ASSERT, and simulation.

Referenced by PYBIND11_MODULE().

endTime()

double OGSSimulation::endTime ( ) const

inline

Definition at line 215 of file ogs_python_module.cpp.

    {
        OGS_ALWAYS_ASSERT(initialized());
        return simulation->endTime();
    }

References initialized(), OGS_ALWAYS_ASSERT, and simulation.

Referenced by PYBIND11_MODULE().

executeSimulation()

int OGSSimulation::executeSimulation ( )

inline

Definition at line 143 of file ogs_python_module.cpp.

    {
        OGS_ALWAYS_ASSERT(initialized());
 
        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);
        }
 
        try
        {
            run_time.start();
            bool solver_succeeded = simulation->executeSimulation();
            simulation->outputLastTimeStep();
            test_definition = simulation->getTestDefinition();
            test_definition_pending = true;
 
            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 ogs_status;
    }

References BaseLib::RunTime::elapsed(), ERR(), BaseLib::formatDate(), INFO(), initialized(), OGS_ALWAYS_ASSERT, ogs_status, simulation, BaseLib::RunTime::start(), test_definition, and test_definition_pending.

Referenced by PYBIND11_MODULE().

executeTimeStep()

int OGSSimulation::executeTimeStep ( )

inline

Definition at line 192 of file ogs_python_module.cpp.

    {
        OGS_ALWAYS_ASSERT(initialized());
 
        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(), initialized(), OGS_ALWAYS_ASSERT, ogs_status, and simulation.

Referenced by PYBIND11_MODULE().

finalize()

int OGSSimulation::finalize ( )

inline

Definition at line 251 of file ogs_python_module.cpp.

    {
        if (simulation)
        {
            simulation->outputLastTimeStep();
            simulation.reset(nullptr);
        }
 
        // 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_SUCCESS && test_definition_pending)
        {
            ogs_status = Simulation::runTestDefinitions(test_definition);
        }
        test_definition_pending = false;
 
        mpi_setup.reset();
 
        return ogs_status;
    }

References BaseLib::ConfigTree::assertNoSwallowedErrors(), ERR(), mpi_setup, ogs_status, Simulation::runTestDefinitions(), simulation, test_definition, and test_definition_pending.

Referenced by PYBIND11_MODULE().

getMesh()

OGSMesh & OGSSimulation::getMesh ( std::string const & name )

inline

Definition at line 221 of file ogs_python_module.cpp.

    {
        OGS_ALWAYS_ASSERT(initialized());
 
        auto const mesh_it = mesh_mapping.find(name);
        if (mesh_it != mesh_mapping.end())
        {
            INFO("found OGSMesh '{}' with address: {}", name,
                 fmt::ptr(&(mesh_it->second)));
            return mesh_it->second;
        }
 
        auto const& [it, success] =
            mesh_mapping.insert({name, OGSMesh(simulation->getMesh(name))});
        if (!success)
        {
            OGS_FATAL("Could not access mesh '{}'.", name);
        }
        INFO("insert OGSMesh '{}' with address: {}", name,
             fmt::ptr(&(it->second)));
        return it->second;
    }

References INFO(), initialized(), mesh_mapping, OGS_ALWAYS_ASSERT, OGS_FATAL, and simulation.

Referenced by PYBIND11_MODULE().

getMeshNames()

std::vector< std::string > OGSSimulation::getMeshNames ( ) const

inline

Definition at line 244 of file ogs_python_module.cpp.

    {
        OGS_ALWAYS_ASSERT(initialized());
 
        return simulation->getMeshNames();
    }

References initialized(), OGS_ALWAYS_ASSERT, and simulation.

Referenced by PYBIND11_MODULE().

initialized()

bool OGSSimulation::initialized ( ) const

inline

Definition at line 285 of file ogs_python_module.cpp.

{ return simulation != nullptr; }

References simulation.

Referenced by currentTime(), endTime(), executeSimulation(), executeTimeStep(), getMesh(), getMeshNames(), and PYBIND11_MODULE().

status()

int OGSSimulation::status ( ) const

inline

Definition at line 283 of file ogs_python_module.cpp.

{ return ogs_status; }

References ogs_status.

Referenced by PYBIND11_MODULE().

Member Data Documentation

mesh_mapping

std::map<std::string, OGSMesh> OGSSimulation::mesh_mapping

private

Definition at line 294 of file ogs_python_module.cpp.

Referenced by getMesh().

mpi_setup

std::optional<BaseLib::MPI::Setup> OGSSimulation::mpi_setup

private

Definition at line 295 of file ogs_python_module.cpp.

Referenced by OGSSimulation(), and finalize().

ogs_status

int OGSSimulation::ogs_status = EXIT_SUCCESS

private

Definition at line 288 of file ogs_python_module.cpp.

Referenced by OGSSimulation(), executeSimulation(), executeTimeStep(), finalize(), and status().

simulation

std::unique_ptr<Simulation> OGSSimulation::simulation

private

Definition at line 290 of file ogs_python_module.cpp.

Referenced by OGSSimulation(), currentTime(), endTime(), executeSimulation(), executeTimeStep(), finalize(), getMesh(), getMeshNames(), and initialized().

test_definition

std::optional<ApplicationsLib::TestDefinition> OGSSimulation::test_definition

private

Initial value:

{
        std::nullopt}

Definition at line 291 of file ogs_python_module.cpp.

                                                              {
        std::nullopt};

Referenced by executeSimulation(), and finalize().

test_definition_pending

bool OGSSimulation::test_definition_pending = false

private

Definition at line 293 of file ogs_python_module.cpp.

Referenced by executeSimulation(), and finalize().

---

The documentation for this class was generated from the following file:

• ogs_python_module.cpp