Made relevant methods in WellCollection and WellsManager to call the reinjection control functions

opm/core/WellCollection.cpp

@@ -122,4 +122,22 @@ namespace Opm
             roots_[i]->applyInjGroupControls();
         }
     }
+
+    /// Applies explicit reinjection controls. This must be called at each timestep to be correct.
+    /// \param[in]    well_reservoirrates_phase
+    ///                         A vector containing reservoir rates by phase for each well.
+    ///                         Is assumed to be ordered the same way as the related Wells-struct,
+    ///                         with all phase rates of a single well adjacent in the array.
+    /// \param[in]    well_surfacerates_phase
+    ///                         A vector containing surface rates by phase for each well.
+    ///                         Is assumed to be ordered the same way as the related Wells-struct,
+    ///                         with all phase rates of a single well adjacent in the array.
+
+    void WellCollection::applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
+                                                          const std::vector<double>& well_surfacerates_phase)
+    {
+        for (size_t i = 0; i < roots_.size(); ++i) {
+            roots_[i]->applyExplicitReinjectionControls(well_reservoirrates_phase, well_surfacerates_phase);
+        }
+    }
 }

opm/core/WellCollection.hpp

@@ -88,6 +88,18 @@ namespace Opm
         /// Applies all group controls (injection and production)
         void applyGroupControls();
         
+        /// Applies explicit reinjection controls. This must be called at each timestep to be correct.
+        /// \param[in]    well_reservoirrates_phase
+        ///                         A vector containing reservoir rates by phase for each well.
+        ///                         Is assumed to be ordered the same way as the related Wells-struct,
+        ///                         with all phase rates of a single well adjacent in the array.
+        /// \param[in]    well_surfacerates_phase
+        ///                         A vector containing surface rates by phase for each well.
+        ///                         Is assumed to be ordered the same way as the related Wells-struct,
+        ///                         with all phase rates of a single well adjacent in the array.
+        void applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
+                                              const std::vector<double>& well_surfacerates_phase);
+        
     private:
         // To account for the possibility of a forest
         std::vector<std::tr1::shared_ptr<WellsGroupInterface> > roots_;

opm/core/WellsManager.cpp

@@ -696,4 +696,20 @@ namespace Opm
                                               well_surfacerates_phase);
     }
 
+    /// Applies explicit reinjection controls. This must be called at each timestep to be correct.
+    /// \param[in]    well_reservoirrates_phase
+    ///                         A vector containing reservoir rates by phase for each well.
+    ///                         Is assumed to be ordered the same way as the related Wells-struct,
+    ///                         with all phase rates of a single well adjacent in the array.
+    /// \param[in]    well_surfacerates_phase
+    ///                         A vector containing surface rates by phase for each well.
+    ///                         Is assumed to be ordered the same way as the related Wells-struct,
+    ///                         with all phase rates of a single well adjacent in the array.
+
+    void WellsManager::applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
+                                                        const std::vector<double>& well_surfacerates_phase)
+    {
+        well_collection_.applyExplicitReinjectionControls(well_reservoirrates_phase, well_surfacerates_phase);
+    }
+
 } // namespace Opm

opm/core/WellsManager.hpp

@@ -87,6 +87,18 @@ namespace Opm
                            const std::vector<double>& well_reservoirrates_phase,
                            const std::vector<double>& well_surfacerates_phase);
         
+        /// Applies explicit reinjection controls. This must be called at each timestep to be correct.
+        /// \param[in]    well_reservoirrates_phase
+        ///                         A vector containing reservoir rates by phase for each well.
+        ///                         Is assumed to be ordered the same way as the related Wells-struct,
+        ///                         with all phase rates of a single well adjacent in the array.
+        /// \param[in]    well_surfacerates_phase
+        ///                         A vector containing surface rates by phase for each well.
+        ///                         Is assumed to be ordered the same way as the related Wells-struct,
+        ///                         with all phase rates of a single well adjacent in the array.
+        void applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
+                                              const std::vector<double>& well_surfacerates_phase);
+
     private:
 	// Disable copying and assignment.
 	WellsManager(const WellsManager& other);