Merge pull request #4656 from akva2/conn_level_ind_to_iface

Move computeConnLevel(Inj|Prod)Ind to WellInterface

opm/simulators/wells/MultisegmentWell.hpp

@@ -148,18 +148,6 @@ namespace Opm
         virtual std::vector<double> computeCurrentWellRates(const Simulator& ebosSimulator,
                                                             DeferredLogger& deferred_logger) const override;
 
-        void computeConnLevelProdInd(const FluidState& fs,
-                                     const std::function<double(const double)>& connPICalc,
-                                     const std::vector<Scalar>& mobility,
-                                     double* connPI) const;
-
-        void computeConnLevelInjInd(const FluidState& fs,
-                                    const Phase preferred_phase,
-                                    const std::function<double(const double)>& connIICalc,
-                                    const std::vector<Scalar>& mobility,
-                                    double* connII,
-                                    DeferredLogger& deferred_logger) const;
-
         std::optional<double>
         computeBhpAtThpLimitProdWithAlq(const Simulator& ebos_simulator,
                                         const SummaryState& summary_state,

opm/simulators/wells/MultisegmentWell_impl.hpp

@@ -1832,84 +1832,6 @@ namespace Opm
     }
 
 
-
-
-
-    template<typename TypeTag>
-    void
-    MultisegmentWell<TypeTag>::
-    computeConnLevelProdInd(const typename MultisegmentWell<TypeTag>::FluidState& fs,
-                            const std::function<double(const double)>& connPICalc,
-                            const std::vector<Scalar>& mobility,
-                            double* connPI) const
-    {
-        const auto& pu = this->phaseUsage();
-        const int   np = this->number_of_phases_;
-        for (int p = 0; p < np; ++p) {
-            // Note: E100's notion of PI value phase mobility includes
-            // the reciprocal FVF.
-            const auto connMob =
-                mobility[ this->flowPhaseToEbosCompIdx(p) ]
-                * fs.invB(this->flowPhaseToEbosPhaseIdx(p)).value();
-
-            connPI[p] = connPICalc(connMob);
-        }
-
-        if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) &&
-            FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx))
-        {
-            const auto io = pu.phase_pos[Oil];
-            const auto ig = pu.phase_pos[Gas];
-
-            const auto vapoil = connPI[ig] * fs.Rv().value();
-            const auto disgas = connPI[io] * fs.Rs().value();
-
-            connPI[io] += vapoil;
-            connPI[ig] += disgas;
-        }
-    }
-
-
-
-
-
-    template<typename TypeTag>
-    void
-    MultisegmentWell<TypeTag>::
-    computeConnLevelInjInd(const typename MultisegmentWell<TypeTag>::FluidState& fs,
-                           const Phase preferred_phase,
-                           const std::function<double(const double)>& connIICalc,
-                           const std::vector<Scalar>& mobility,
-                           double* connII,
-                           DeferredLogger& deferred_logger) const
-    {
-        // Assumes single phase injection
-        const auto& pu = this->phaseUsage();
-
-        auto phase_pos = 0;
-        if (preferred_phase == Phase::GAS) {
-            phase_pos = pu.phase_pos[Gas];
-        }
-        else if (preferred_phase == Phase::OIL) {
-            phase_pos = pu.phase_pos[Oil];
-        }
-        else if (preferred_phase == Phase::WATER) {
-            phase_pos = pu.phase_pos[Water];
-        }
-        else {
-            OPM_DEFLOG_THROW(NotImplemented,
-                             fmt::format("Unsupported Injector Type ({}) "
-                                         "for well {} during connection I.I. calculation",
-                                         static_cast<int>(preferred_phase), this->name()),
-                             deferred_logger);
-        }
-
-        const Scalar mt     = std::accumulate(mobility.begin(), mobility.end(), 0.0);
-        connII[phase_pos] = connIICalc(mt * fs.invB(this->flowPhaseToEbosPhaseIdx(phase_pos)).value());
-    }
-
-
-
     template <typename TypeTag>
     std::vector<double>
     MultisegmentWell<TypeTag>::

opm/simulators/wells/StandardWell.hpp

@@ -241,18 +241,6 @@ namespace Opm
         virtual std::vector<double> computeCurrentWellRates(const Simulator& ebosSimulator,
                                                             DeferredLogger& deferred_logger) const override;
 
-        void computeConnLevelProdInd(const FluidState& fs,
-                                     const std::function<double(const double)>& connPICalc,
-                                     const std::vector<EvalWell>& mobility,
-                                     double* connPI) const;
-
-        void computeConnLevelInjInd(const typename StandardWell<TypeTag>::FluidState& fs,
-                                    const Phase preferred_phase,
-                                    const std::function<double(const double)>& connIICalc,
-                                    const std::vector<EvalWell>& mobility,
-                                    double* connII,
-                                    DeferredLogger& deferred_logger) const;
-
         std::vector<double> getPrimaryVars() const override;
 
         int setPrimaryVars(std::vector<double>::const_iterator it) override;

opm/simulators/wells/StandardWell_impl.hpp

@@ -1341,7 +1341,7 @@ namespace Opm
                 return wellPICalc.connectionProdIndStandard(allPerfID, mobility);
             };
 
-            std::vector<EvalWell> mob(this->num_components_, {this->primary_variables_.numWellEq() + Indices::numEq, 0.0});
+            std::vector<Scalar> mob(this->num_components_, 0.0);
             getMobility(ebosSimulator, static_cast<int>(subsetPerfID), mob, deferred_logger);
 
             const auto& fs = fluidState(subsetPerfID);
@@ -2397,86 +2397,6 @@ namespace Opm
 
 
 
-
-
-    template <typename TypeTag>
-    void
-    StandardWell<TypeTag>::
-    computeConnLevelProdInd(const typename StandardWell<TypeTag>::FluidState& fs,
-                            const std::function<double(const double)>& connPICalc,
-                            const std::vector<EvalWell>& mobility,
-                            double* connPI) const
-    {
-        const auto& pu = this->phaseUsage();
-        const int   np = this->number_of_phases_;
-        for (int p = 0; p < np; ++p) {
-            // Note: E100's notion of PI value phase mobility includes
-            // the reciprocal FVF.
-            const auto connMob =
-                mobility[ this->flowPhaseToEbosCompIdx(p) ].value()
-                    * fs.invB(this->flowPhaseToEbosPhaseIdx(p)).value();
-
-            connPI[p] = connPICalc(connMob);
-        }
-
-        if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) &&
-            FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx))
-        {
-            const auto io = pu.phase_pos[Oil];
-            const auto ig = pu.phase_pos[Gas];
-
-            const auto vapoil = connPI[ig] * fs.Rv().value();
-            const auto disgas = connPI[io] * fs.Rs().value();
-
-            connPI[io] += vapoil;
-            connPI[ig] += disgas;
-        }
-    }
-
-
-
-
-
-    template <typename TypeTag>
-    void
-    StandardWell<TypeTag>::
-    computeConnLevelInjInd(const typename StandardWell<TypeTag>::FluidState& fs,
-                           const Phase preferred_phase,
-                           const std::function<double(const double)>& connIICalc,
-                           const std::vector<EvalWell>& mobility,
-                           double* connII,
-                           DeferredLogger& deferred_logger) const
-    {
-        // Assumes single phase injection
-        const auto& pu = this->phaseUsage();
-
-        auto phase_pos = 0;
-        if (preferred_phase == Phase::GAS) {
-            phase_pos = pu.phase_pos[Gas];
-        }
-        else if (preferred_phase == Phase::OIL) {
-            phase_pos = pu.phase_pos[Oil];
-        }
-        else if (preferred_phase == Phase::WATER) {
-            phase_pos = pu.phase_pos[Water];
-        }
-        else {
-            OPM_DEFLOG_THROW(NotImplemented,
-                             fmt::format("Unsupported Injector Type ({}) "
-                                         "for well {} during connection I.I. calculation",
-                                         static_cast<int>(preferred_phase), this->name()),
-                             deferred_logger);
-        }
-
-        const auto zero   = EvalWell{this->primary_variables_.numWellEq() + Indices::numEq, 0.0};
-        const auto mt     = std::accumulate(mobility.begin(), mobility.end(), zero);
-        connII[phase_pos] = connIICalc(mt.value() * fs.invB(this->flowPhaseToEbosPhaseIdx(phase_pos)).value());
-    }
-
-
-
-
-
     template <typename TypeTag>
     std::vector<double>
     StandardWell<TypeTag>::

opm/simulators/wells/WellInterface.hpp

@@ -414,7 +414,17 @@ protected:
                      Callback& extendEval,
                      [[maybe_unused]] DeferredLogger& deferred_logger) const;
 
+    void computeConnLevelProdInd(const FluidState& fs,
+                                 const std::function<double(const double)>& connPICalc,
+                                 const std::vector<Scalar>& mobility,
+                                 double* connPI) const;
 
+    void computeConnLevelInjInd(const FluidState& fs,
+                                const Phase preferred_phase,
+                                const std::function<double(const double)>& connIICalc,
+                                const std::vector<Scalar>& mobility,
+                                double* connII,
+                                DeferredLogger& deferred_logger) const;
 };
 
 }

opm/simulators/wells/WellInterface_impl.hpp

@@ -1300,4 +1300,74 @@ namespace Opm
         }
     }
 
+    template <typename TypeTag>
+    void
+    WellInterface<TypeTag>::
+    computeConnLevelProdInd(const FluidState& fs,
+                            const std::function<double(const double)>& connPICalc,
+                            const std::vector<Scalar>& mobility,
+                            double* connPI) const
+    {
+        const auto& pu = this->phaseUsage();
+        const int   np = this->number_of_phases_;
+        for (int p = 0; p < np; ++p) {
+            // Note: E100's notion of PI value phase mobility includes
+            // the reciprocal FVF.
+            const auto connMob =
+                mobility[this->flowPhaseToEbosCompIdx(p)]
+                    * fs.invB(this->flowPhaseToEbosPhaseIdx(p)).value();
+
+            connPI[p] = connPICalc(connMob);
+        }
+
+        if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) &&
+            FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx))
+        {
+            const auto io = pu.phase_pos[Oil];
+            const auto ig = pu.phase_pos[Gas];
+
+            const auto vapoil = connPI[ig] * fs.Rv().value();
+            const auto disgas = connPI[io] * fs.Rs().value();
+
+            connPI[io] += vapoil;
+            connPI[ig] += disgas;
+        }
+    }
+
+
+    template <typename TypeTag>
+    void
+    WellInterface<TypeTag>::
+    computeConnLevelInjInd(const FluidState& fs,
+                           const Phase preferred_phase,
+                           const std::function<double(const double)>& connIICalc,
+                           const std::vector<Scalar>& mobility,
+                           double* connII,
+                           DeferredLogger& deferred_logger) const
+    {
+        // Assumes single phase injection
+        const auto& pu = this->phaseUsage();
+
+        auto phase_pos = 0;
+        if (preferred_phase == Phase::GAS) {
+            phase_pos = pu.phase_pos[Gas];
+        }
+        else if (preferred_phase == Phase::OIL) {
+            phase_pos = pu.phase_pos[Oil];
+        }
+        else if (preferred_phase == Phase::WATER) {
+            phase_pos = pu.phase_pos[Water];
+        }
+        else {
+            OPM_DEFLOG_THROW(NotImplemented,
+                             fmt::format("Unsupported Injector Type ({}) "
+                                         "for well {} during connection I.I. calculation",
+                                         static_cast<int>(preferred_phase), this->name()),
+                             deferred_logger);
+        }
+
+        const auto mt     = std::accumulate(mobility.begin(), mobility.end(), 0.0);
+        connII[phase_pos] = connIICalc(mt * fs.invB(this->flowPhaseToEbosPhaseIdx(phase_pos)).value());
+    }
+
 } // namespace Opm