FlowGenericVanguard.hpp

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
  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 2 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/>.
 
  Consult the COPYING file in the top-level source directory of this
  module for the precise wording of the license and the list of
  copyright holders.
*/
#ifndef OPM_FLOW_GENERIC_VANGUARD_HPP
#define OPM_FLOW_GENERIC_VANGUARD_HPP
 
#include <dune/common/parallel/communication.hh>
 
#include <opm/common/OpmLog/OpmLog.hpp>
 
#include <opm/grid/common/GridEnums.hpp>
 
#include <opm/input/eclipse/Schedule/Well/WellTestState.hpp>
 
#include <opm/simulators/utils/ParallelCommunication.hpp>
 
#include <cassert>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace Opm::Parameters {
 
struct AllowDistributedWells { static constexpr bool value = false; };
struct AllowSplittingInactiveWells { static constexpr bool value = true; };
 
struct EclOutputInterval { static constexpr int value = -1; };
struct EdgeWeightsMethod  { static constexpr auto value = "transmissibility"; };
struct EnableDryRun { static constexpr auto value = "auto"; };
struct EnableEclOutput { static constexpr auto value = true; };
struct EnableOpmRstFile { static constexpr bool value = false; };
struct ExternalPartition { static constexpr auto* value = ""; };
 
template<class Scalar>
struct ImbalanceTol { static constexpr Scalar value = 1.1; };
 
struct IgnoreKeywords { static constexpr auto value = ""; };
struct InputSkipMode { static constexpr auto value = "100"; };
struct MetisParams { static constexpr auto value = "default"; };
 
#if HAVE_OPENCL || HAVE_ROCSPARSE || HAVE_CUDA
struct NumJacobiBlocks { static constexpr int value = 0; };
#endif // HAVE_OPENCL || HAVE_ROCSPARSE || HAVE_CUDA
 
struct OwnerCellsFirst { static constexpr bool value = true; };
struct ParsingStrictness { static constexpr auto value = "normal"; };
struct ActionParsingStrictness { static constexpr auto value = "normal"; };
 
struct PartitionMethod { static constexpr auto value = "zoltanwell"; };
struct AddCorners { static constexpr bool value = false; };
struct NumOverlap { static constexpr int value = 1; };
 
struct SchedRestart{ static constexpr bool value = false; };
struct SerialPartitioning{ static constexpr bool value = false; };
 
template<class Scalar>
struct ZoltanImbalanceTol { static constexpr Scalar value = 1.1; };
 
struct ZoltanPhgEdgeSizeThreshold { static constexpr auto value = 0.35; };
 
struct ZoltanParams { static constexpr auto value = "graph"; };
 
} // namespace Opm::Parameters
 
namespace Opm {
 
namespace Action { class State; }
class Deck;
class EclipseState;
struct NumericalAquiferCell;
class ParseContext;
class Schedule;
class Python;
class SummaryConfig;
class SummaryState;
class UDQState;
class WellTestState;
 
class FlowGenericVanguard {
public:
    using ParallelWellStruct = std::vector<std::pair<std::string,bool>>;
 
    struct SimulationModelParams {
        double setupTime_;
        std::unique_ptr<UDQState> udqState_;
        std::unique_ptr<Action::State> actionState_;
        std::unique_ptr<SummaryState> summaryState_;
        std::unique_ptr<WellTestState> wtestState_;
        std::shared_ptr<EclipseState> eclState_;
        std::shared_ptr<Schedule> eclSchedule_;
        std::shared_ptr<SummaryConfig> eclSummaryConfig_;
    };
 
    static SimulationModelParams modelParams_;
 
    FlowGenericVanguard();
    explicit FlowGenericVanguard(SimulationModelParams&& params);
 
    ~FlowGenericVanguard();
 
    static SimulationModelParams serializationTestParams();
 
    static std::string canonicalDeckPath(const std::string& caseName);
 
    double setupTime()
    { return setupTime_; }
 
    static void readDeck(const std::string& filename);
 
    void defineSimulationModel(SimulationModelParams&& params);
 
    const EclipseState& eclState() const
    { return *eclState_; }
 
    EclipseState& eclState()
    { return *eclState_; }
 
    const Schedule& schedule() const
    { return *eclSchedule_; }
 
    Schedule& schedule()
    { return *eclSchedule_; }
 
    const SummaryConfig& summaryConfig() const
    { return *eclSummaryConfig_; }
 
    SummaryState& summaryState()
    { return *summaryState_; }
 
    const SummaryState& summaryState() const
    { return *summaryState_; }
 
    Action::State& actionState()
    { return *actionState_; }
 
    const Action::State& actionState() const
    { return *actionState_; }
 
    UDQState& udqState()
    { return *udqState_; }
 
    const UDQState& udqState() const
    { return *udqState_; }
 
    std::unique_ptr<WellTestState> transferWTestState() {
        return std::move(this->wtestState_);
    }
 
 
    const std::string& caseName() const
    { return caseName_; }
 
    Dune::EdgeWeightMethod edgeWeightsMethod() const
    { return edgeWeightsMethod_; }
 
    int numJacobiBlocks() const
    {
#if HAVE_OPENCL || HAVE_ROCSPARSE || HAVE_CUDA
        return numJacobiBlocks_;
#else
        return 0;
#endif // HAVE_OPENCL || HAVE_ROCSPARSE || HAVE_CUDA
    }
 
    bool ownersFirst() const
    { return ownersFirst_; }
 
#if HAVE_MPI
    bool addCorners() const
    { return addCorners_; }
 
    int numOverlap() const
    { return numOverlap_; }
 
    Dune::PartitionMethod partitionMethod() const
    { return partitionMethod_; }
 
    bool serialPartitioning() const
    { return serialPartitioning_; }
 
    double imbalanceTol() const
    {
        if (zoltanImbalanceTolSet_) {
            OpmLog::info("The parameter --zoltan-imbalance-tol is deprecated "
                         "and has been renamed to --imbalance-tol, please "
                         "adjust your calls and scripts!");
            return zoltanImbalanceTol_;
        } else {
            return imbalanceTol_;
        }
    }
 
    const std::string& externalPartitionFile() const
    {
        return this->externalPartitionFile_;
    }
#endif // HAVE_MPI
 
    bool enableDistributedWells() const
    { return enableDistributedWells_; }
 
    bool enableEclOutput() const
    { return enableEclOutput_; }
 
    const ParallelWellStruct& parallelWells() const
    { return parallelWells_; }
 
    static void setCommunication(std::unique_ptr<Opm::Parallel::Communication> comm)
    { comm_ = std::move(comm); }
 
    static Parallel::Communication& comm()
    {
        assert(comm_ != nullptr);
        return *comm_;
    }
 
    // Private to avoid pulling schedule in header.
    // Static state is not serialized, only use for restart.
    template<class Serializer>
    void serializeOp(Serializer& serializer);
 
    // Only compares dynamic state.
    bool operator==(const FlowGenericVanguard& rhs) const;
 
protected:
    void updateOutputDir_(std::string outputDir,
                          bool enableEclCompatFile);
 
    void updateNOSIM_(std::string_view enableDryRun);
 
    bool drsdtconEnabled() const;
 
    std::unordered_map<std::size_t, const NumericalAquiferCell*> allAquiferCells() const;
 
    void init();
 
    template<class Scalar>
    static void registerParameters_();
 
    double setupTime_;
 
    // These variables may be owned by both Python and the simulator
    static std::unique_ptr<Parallel::Communication> comm_;
 
    std::string caseName_;
    std::string fileName_;
    Dune::EdgeWeightMethod edgeWeightsMethod_;
 
#if HAVE_OPENCL || HAVE_ROCSPARSE || HAVE_CUDA
    int numJacobiBlocks_{0};
#endif // HAVE_OPENCL || HAVE_ROCSPARSE || HAVE_CUDA
 
    bool ownersFirst_;
#if HAVE_MPI
    bool addCorners_;
    int numOverlap_;
 
    Dune::PartitionMethod partitionMethod_;
    bool serialPartitioning_;
    double imbalanceTol_;
 
    bool zoltanImbalanceTolSet_;
    double zoltanImbalanceTol_;
    double zoltanPhgEdgeSizeThreshold_;
    std::string zoltanParams_;
 
    std::string metisParams_;
 
    std::string externalPartitionFile_{};
#endif // HAVE_MPI
 
    bool enableDistributedWells_;
    bool enableEclOutput_;
    bool allow_splitting_inactive_wells_;
 
    std::string ignoredKeywords_;
    std::optional<int> outputInterval_;
    bool useMultisegmentWell_;
    bool enableExperiments_;
 
    std::unique_ptr<SummaryState> summaryState_;
    std::unique_ptr<UDQState> udqState_;
    std::unique_ptr<Action::State> actionState_;
 
    // Observe that this instance is handled differently from the other state
    // variables, it will only be initialized for a restart run. While
    // initializing a restarted run this instance is transferred to the WGState
    // member in the well model.
    std::unique_ptr<WellTestState> wtestState_;
 
    // these attributes point  either to the internal  or to the external version of the
    // parser objects.
    std::shared_ptr<Python> python;
    // These variables may be owned by both Python and the simulator
    std::shared_ptr<EclipseState> eclState_;
    std::shared_ptr<Schedule> eclSchedule_;
    std::shared_ptr<SummaryConfig> eclSummaryConfig_;
 
    ParallelWellStruct parallelWells_;
};
 
} // namespace Opm
 
#endif // OPM_FLOW_GENERIC_VANGUARD_HPP