PyMain.hpp

/*
  Copyright 2013, 2014, 2015 SINTEF ICT, Applied Mathematics.
  Copyright 2014 Dr. Blatt - HPC-Simulation-Software & Services
  Copyright 2015 IRIS AS
  Copyright 2014 STATOIL ASA.
  Copyright 2023 Inria

  This file is part of the Open Porous Media project (OPM).

  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OPM_PYMAINBO_HEADER_INCLUDED
#define OPM_PYMAINBO_HEADER_INCLUDED

#include <opm/simulators/flow/FlowMain.hpp>
#include <opm/simulators/flow/Main.hpp>

#include <cstddef>
#include <cstdlib>
#include <memory>
#include <string>
#include <vector>

namespace Opm {

template<class TypeTag>
std::unique_ptr<FlowMain<TypeTag>>
flowMainInit(int argc, char** argv, bool outputCout, bool outputFiles)
{
    // we always want to use the default locale, and thus spare us the trouble
    // with incorrect locale settings.
    resetLocale();

    return std::make_unique<FlowMain<TypeTag>>(argc, argv, outputCout, outputFiles);
}

// Adds a python-only initialization method
template<class TypeTag>
class PyMain : public Main
{
public:
    using FlowMainType = FlowMain<TypeTag>;

    using Main::Main;

    void setArguments(const std::vector<std::string>& args)
    {
        if (args.empty()) {
            return;
        }

        // We have the two arguments previously setup (binary name and input
        // case name) by the main class plus whichever args are in the
        // parameter that was passed from the python side.
        this->argc_ = 2 + args.size();

        // Setup our vector of char*'s
        argv_python_.resize(2 + args.size());
        argv_python_[0] = argv_[0];
        argv_python_[1] = argv_[1];
        for (std::size_t i = 0; i < args.size(); ++i) {
            argv_python_[i+2] = const_cast<char*>(args[i].c_str());
        }

        // Finally set the main class' argv pointer to the combined
        // parameter list.
        this->argv_ = argv_python_.data();
    }

    // To be called from the Python interface code.  Only do the
    // initialization and then return a pointer to the FlowMain object that
    // can later be accessed directly from the Python interface to
    // e.g. advance the simulator one report step
    std::unique_ptr<FlowMainType> initFlowBlackoil(int& exitCode)
    {
        exitCode = EXIT_SUCCESS;

        if (this->initialize_<Properties::TTag::FlowEarlyBird>(exitCode, true)) {
            // TODO: check that this deck really represents a blackoil
            // case. E.g. check that number of phases == 3
            this->setupVanguard();

            return flowMainInit<TypeTag>(argc_, argv_, outputCout_, outputFiles_);
        }

        // NOTE: exitCode was set by initialize_() above;
        return {}; // nullptr
    }

private:
    std::vector<char*> argv_python_{};
};

} // namespace Opm

#endif // OPM_PYMAINBO_HEADER_INCLUDED