include group controls for zero rate target checking

OPM · Feb 28, 2024 · d3abaad · d3abaad
1 parent 3087950
commit d3abaad
Show file tree

Hide file tree

Showing 3 changed files with 76 additions and 1 deletion.
diff --git a/opm/simulators/wells/StandardWell_impl.hpp b/opm/simulators/wells/StandardWell_impl.hpp
@@ -2349,8 +2349,11 @@ namespace Opm
         const bool allow_open =  this->well_ecl_.getStatus() == WellStatus::OPEN &&
                                  well_state.well(this->index_of_well_).status == WellStatus::OPEN;
         // don't allow switcing for wells under zero rate target or requested fixed status and control
-        const bool allow_switching = !this->wellUnderZeroRateTarget(summary_state, well_state) &&
+        //const bool allow_switching = !this->wellUnderZeroRateTarget(summary_state, well_state) &&
+         //                            (!fixed_control || !fixed_status) && allow_open;
+        const bool allow_switching = !this->wellUnderZeroRateTargetVersion(ebosSimulator, well_state, deferred_logger) &&
                                      (!fixed_control || !fixed_status) && allow_open;
+
         bool changed = false;
         bool final_check = false;
         // well needs to be set operable or else solving/updating of re-opened wells is skipped

diff --git a/opm/simulators/wells/WellInterface.hpp b/opm/simulators/wells/WellInterface.hpp
@@ -232,6 +232,14 @@ class WellInterface : public WellInterfaceIndices<GetPropType<TypeTag, Propertie
                                                    std::vector<double>& well_flux,
                                                    DeferredLogger& deferred_logger) const = 0;
 
+    bool wellUnderZeroRateTargetVersion(const Simulator& ebos_simulator,
+                                        const WellState& well_state,
+                                        DeferredLogger& deferred_logger) const;
+
+    bool stoppedOrZeroRateTargetVersion(const Simulator& ebos_simulator,
+                                        const WellState& well_state,
+                                        DeferredLogger& deferred_logger) const;
+
     bool updateWellStateWithTHPTargetProd(const Simulator& ebos_simulator,
                                           WellState& well_state,
                                           DeferredLogger& deferred_logger) const;

diff --git a/opm/simulators/wells/WellInterface_impl.hpp b/opm/simulators/wells/WellInterface_impl.hpp
@@ -1396,6 +1396,70 @@ namespace Opm
         }
     }
 
+    template<typename TypeTag>
+    bool
+    WellInterface<TypeTag>::
+    wellUnderZeroRateTargetVersion(const Simulator& ebos_simulator,
+                                   const WellState& well_state,
+                                   DeferredLogger& deferred_logger) const
+    {
+        // Extended version of WellInterfaceGeneric::wellUnderZeroRateTarget that also checks group controls
+        const auto& ws = well_state.well(this->index_of_well_);
+        const auto& summaryState = ebos_simulator.vanguard().summaryState();
+        const bool isGroupControlled = (this->isInjector() && ws.injection_cmode == Well::InjectorCMode::GRUP) ||
+                                       (this->isProducer() && ws.production_cmode == Well::ProducerCMode::GRUP);
+        if (!isGroupControlled) {
+            // well is not under group control, check "light-weight" version
+            return this->wellUnderZeroRateTarget(summaryState, well_state);
+        } else {
+            const auto& well = this->well_ecl_;
+            const auto& schedule = ebos_simulator.vanguard().schedule();
+            const auto& group_state = ebos_simulator.problem().wellModel().groupState();
+            const auto& group = schedule.getGroup(well.groupName(), this->currentStep());
+            const double efficiencyFactor = well.getEfficiencyFactor();
+            if (this->isInjector()) {
+                // Check injector under group control
+                const auto& controls = well.injectionControls(summaryState);
+                std::optional<double> target = this->getGroupInjectionTargetRate(group,
+                                                                                 well_state,
+                                                                                 group_state,
+                                                                                 schedule,
+                                                                                 summaryState,
+                                                                                 controls.injector_type,
+                                                                                 efficiencyFactor,
+                                                                                 deferred_logger);
+            if (target.has_value()) {
+                return target.value() == 0.0;
+            } else {
+                return false;
+            }
+            } else {
+                // Check producer under group control
+                double scale = this->getGroupProductionTargetRate(group,
+                                                                  well_state,
+                                                                  group_state,
+                                                                  schedule,
+                                                                  summaryState,
+                                                                  efficiencyFactor,
+                                                                  deferred_logger);
+                return scale == 0.0;
+            }
+        }
+    }
+
+    template<typename TypeTag>
+    bool
+    WellInterface<TypeTag>::
+    stoppedOrZeroRateTargetVersion(const Simulator& ebos_simulator,
+                                   const WellState& well_state,
+                                   DeferredLogger& deferred_logger) const
+    {
+        // Extended version of WellInterfaceGeneric::stopppedOrZeroRateTarget that also checks group controls
+        return (this->wellIsStopped() || wellUnderZeroRateTargetVersion(ebos_simulator, 
+                                                                        well_state, 
+                                                                        deferred_logger));
+    }
+
     template<typename TypeTag>
     std::vector<double>
     WellInterface<TypeTag>::