ParallelWBPCalculation.hpp

Go to the documentation of this file.

/*
  Copyright 2023 Equinor ASA.
 
  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 PARALLEL_WBP_CALCULATION_HPP
#define PARALLEL_WBP_CALCULATION_HPP
 
#include <opm/simulators/wells/ParallelPAvgDynamicSourceData.hpp>
 
#include <opm/simulators/utils/ParallelCommunication.hpp>
 
#include <opm/simulators/wells/PerforationData.hpp>
 
#include <opm/input/eclipse/Schedule/Well/PAvgCalculator.hpp>
#include <opm/input/eclipse/Schedule/Well/PAvgCalculatorCollection.hpp>
 
#include <cstddef>
#include <functional>
#include <memory>
#include <vector>
 
namespace Opm {
    class GridDims;
    template<class Scalar> class ParallelWellInfo;
    class PAvg;
    class Well;
}
 
namespace Opm {
 
template<class Scalar>
class ParallelWBPCalculation
{
public:
    using GlobalToLocal = typename ParallelPAvgDynamicSourceData<Scalar>::GlobalToLocal;
 
    using Evaluator = typename ParallelPAvgDynamicSourceData<Scalar>::Evaluator;
 
    using EvaluatorFactory = std::function<Evaluator()>;
 
    explicit ParallelWBPCalculation(const GridDims&                cellIndexMap,
                                    const Parallel::Communication& gridComm);
 
    ParallelWBPCalculation& localCellIndex(GlobalToLocal localCellIdx);
 
    ParallelWBPCalculation& evalCellSource(Evaluator evalCellSrc);
 
    std::size_t
    createCalculator(const Well&             well,
                     const ParallelWellInfo<Scalar>& parallelWellInfo,
                     const std::vector<int>& localConnIdx,
                     EvaluatorFactory        makeWellSourceEvaluator);
 
    void defineCommunication();
 
    void collectDynamicValues();
 
    void inferBlockAveragePressures(const std::size_t calcIndex,
                                    const PAvg&       controls,
                                    const Scalar      gravity,
                                    const Scalar      refDepth);
 
    const typename PAvgCalculator<Scalar>::Result&
    averagePressures(const std::size_t calcIndex) const;
 
private:
    class LocalConnSet
    {
    public:
        explicit LocalConnSet(const std::vector<int>& localConnIdx);
 
        int localIndex(const std::size_t connIdx) const;
 
    private:
        std::vector<int> localConnIdx_{};
    };
 
    class SourceData
    {
    public:
        operator const ParallelPAvgDynamicSourceData<Scalar>&() const
        {
            return *this->srcData_;
        }
 
        explicit SourceData(const Parallel::Communication& comm);
 
        SourceData& localIndex(GlobalToLocal localIdx);
 
        SourceData& evaluator(Evaluator eval);
 
        SourceData& evaluatorFactory(EvaluatorFactory evalFactory);
 
        void buildStructure(const std::vector<std::size_t>& sourceLocations);
 
        void collectDynamicValues();
 
        const Parallel::Communication& comm() const
        {
            return this->comm_.get();
        }
 
        std::vector<int>
        getLocalIndex(const std::vector<std::size_t>& globalIndex) const;
 
    private:
        using DataPtr = std::unique_ptr<ParallelPAvgDynamicSourceData<Scalar>>;
 
        std::reference_wrapper<const Parallel::Communication> comm_;
 
        GlobalToLocal localIdx_{};
 
        Evaluator eval_{};
 
        EvaluatorFactory evalFactory_{};
 
        DataPtr srcData_{};
    };
 
    using WellID = typename std::vector<SourceData>::size_type;
 
    std::reference_wrapper<const GridDims> cellIndexMap_;
 
    SourceData reservoirSrc_;
 
    PAvgCalculatorCollection<Scalar> calculators_{};
 
    std::vector<SourceData> wellConnSrc_{};
 
    std::vector<LocalConnSet> localConnSet_{};
 
    void pruneInactiveWBPCells();
 
    void pruneInactiveWBPCellsSerial();
 
    void pruneInactiveWBPCellsParallel();
 
    void defineReservoirCommunication();
 
    void defineWellCommunication(const std::size_t well);
 
    typename PAvgCalculator<Scalar>::Sources
    makeEvaluationSources(const WellID well) const;
};
 
} // namespace Opm
 
#endif // PARALLEL_WBP_CALCULATION_HPP