adding updateWellControl to MultisegmentWell

it turned out to be same with the one in StandardWell
considerng to make it in the WellInterface.

opm/autodiff/MultisegmentWell.hpp

@@ -102,11 +102,11 @@ namespace Opm
         /// updating the well state based the control mode specified with current
         // TODO: later will check wheter we need current
         virtual void updateWellStateWithTarget(const int current,
-                                               WellState& xw) const;
+                                               WellState& well_state) const;
 
         // TODO: this should go to the WellInterface, while updateWellStateWithTarget
         // will need touch different types of well_state, we will see.
-        virtual void updateWellControl(WellState& xw,
+        virtual void updateWellControl(WellState& well_state,
                                        wellhelpers::WellSwitchingLogger& logger) const;
 
         /// check whether the well equations get converged for this well
@@ -118,7 +118,7 @@ namespace Opm
         virtual void computeAccumWell();
 
         virtual void computeWellConnectionPressures(const Simulator& ebosSimulator,
-                                                    const WellState& xw);
+                                                    const WellState& well_state);
 
         /// Ax = Ax - C D^-1 B x
         virtual void apply(const BVector& x, BVector& Ax) const;
@@ -174,6 +174,7 @@ namespace Opm
         // protected functions from the Base class
         using Base::active;
         using Base::phaseUsage;
+        using Base::name;
 
         // TODO: trying to use the information from the Well opm-parser as much
         // as possible, it will possibly be re-implemented later for efficiency reason.

opm/autodiff/MultisegmentWell_impl.hpp

@@ -332,7 +332,59 @@ namespace Opm
     updateWellControl(WellState& well_state,
                       wellhelpers::WellSwitchingLogger& logger) const
     {
-        // TODO: it will be very similar to the StandardWell, while updateWellStateWithTarget will be chanlleging.
+        const int np = number_of_phases_;
+        const int nw = well_state.bhp().size();
+        const int w = index_of_well_;
+
+        const int old_control_index = well_state.currentControls()[w];
+
+        // Find, for each well, if any constraints are broken. If so,
+        // switch control to first broken constraint.
+        WellControls* wc = well_controls_;
+
+        // Loop over all controls except the current one, and also
+        // skip any RESERVOIR_RATE controls, since we cannot
+        // handle those.
+        const int nwc = well_controls_get_num(wc);
+        // the current control index
+        int current = well_state.currentControls()[w];
+        int ctrl_index = 0;
+        for (; ctrl_index < nwc; ++ctrl_index) {
+            if (ctrl_index == current) {
+                // This is the currently used control, so it is
+                // used as an equation. So this is not used as an
+                // inequality constraint, and therefore skipped.
+                continue;
+            }
+            if (wellhelpers::constraintBroken(
+                    well_state.bhp(), well_state.thp(), well_state.wellRates(),
+                    w, np, well_type_, wc, ctrl_index)) {
+                // ctrl_index will be the index of the broken constraint after the loop.
+                break;
+            }
+        }
+
+        if (ctrl_index != nwc) {
+            // Constraint number ctrl_index was broken, switch to it.
+            well_state.currentControls()[w] = ctrl_index;
+            current = well_state.currentControls()[w];
+            well_controls_set_current( wc, current);
+        }
+
+        // the new well control indices after all the related updates,
+        const int updated_control_index = well_state.currentControls()[w];
+
+        // checking whether control changed
+        if (updated_control_index != old_control_index) {
+            logger.wellSwitched(name(),
+                                well_controls_iget_type(wc, old_control_index),
+                                well_controls_iget_type(wc, updated_control_index));
+        }
+
+        if (updated_control_index != old_control_index) { //  || well_collection_->groupControlActive()) {
+            updateWellStateWithTarget(updated_control_index, well_state);
+        }
+        // TODO: should we make it a function in the base?
     }