TheBSEagleProject: well_rate_control_rate

00001 
00010 #ifndef BS_WELLS_WELL_RATE_CONTROL_RATE_DERIV_H_
00011 #define BS_WELLS_WELL_RATE_CONTROL_RATE_DERIV_H_
00012 
00013 #include "well_rate_control_deriv.h"
00014 #include "well_rate_control_compute_deriv_typedef.h"
00015 
00016 namespace blue_sky
00017   {
00018   namespace wells
00019     {
00020 
00021     template <typename mobility_calc_t>
00022     struct compute_rate_deriv_3p : public compute_deriv <mobility_calc_t>
00023       {
00024         GET_COMPUTE_DERIV_BASE_TYPES;
00025 
00026         compute_rate_deriv_3p (const mobility_calc_t &mobility_calc)
00027             : base_t (mobility_calc)
00028         {
00029         }
00030 
00031         void
00032         oil_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00033           {
00034             array_ext <item_t> rw_block = c->get_rw_value ();
00035             array_ext <item_t> wr_block = c->get_wr_value ();
00036             array_ext <item_t> rr_block = c->get_rr_value ();
00037             array_ext <item_t> ww_value = params.ww_value;
00038             item_t rw                   = 0;
00039 
00040             if (mobility_calc_t::is_oil_injection (params))
00041               {
00042                 rw = rw_block [p3_oil] = /*this->mult * */base_t::compute_oil_pref_deriv (data, params);
00043               }
00044             if (mobility_calc_t::is_o_ctrl (params))
00045               {
00046                 ww_value[0] += rw/* * this->mult*/;
00047                 wr_block[0] += (rr_block[p3_oil * 3 + 0]/* * this->mult*/);
00048                 wr_block[1] += (rr_block[p3_oil * 3 + 1]/* * this->mult*/);
00049                 wr_block[2] += (rr_block[p3_oil * 3 + 2]/* * this->mult*/);
00050               }
00051           }
00052         void
00053         water_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00054           {
00055             array_ext <item_t> rw_block = c->get_rw_value ();
00056             array_ext <item_t> wr_block = c->get_wr_value ();
00057             array_ext <item_t> rr_block = c->get_rr_value ();
00058             array_ext <item_t> ww_value = params.ww_value;
00059             item_t rw                   = 0;
00060 
00061             if (mobility_calc_t::is_water_injection (params))
00062               {
00063                 rw = rw_block [p3_wat] = /*this->mult * */base_t::compute_water_pref_deriv (data, params);
00064 #ifdef _DEBUG
00065                 //BOSOUT (section::wells, level::debug) << boost::format ("[%s : %d] rw: %.20e") % params.well_->name ().c_str () % params.n_block % rw << bs_end;
00066 #endif
00067               }
00068             if (mobility_calc_t::is_w_ctrl (params))
00069               {
00070                 ww_value[0] += rw/* * this->mult*/;
00071                 wr_block[0] += (rr_block[p3_wat * 3 + 0]/* * this->mult*/);
00072                 wr_block[1] += (rr_block[p3_wat * 3 + 1]/* * this->mult*/);
00073                 wr_block[2] += (rr_block[p3_wat * 3 + 2]/* * this->mult*/);
00074               }
00075           }
00076         void
00077         gas_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00078           {
00079             array_ext <item_t> rw_block = c->get_rw_value ();
00080             array_ext <item_t> wr_block = c->get_wr_value ();
00081             array_ext <item_t> rr_block = c->get_rr_value ();
00082             array_ext <item_t> ww_value = params.ww_value;
00083             item_t rw                   = 0;
00084 
00085             if (mobility_calc_t::is_gas_injection (params))
00086               {
00087                 rw = rw_block [p3_gas] = /*this->mult * */base_t::compute_gas_pref_deriv (data, params);
00088               }
00089             if (mobility_calc_t::is_g_ctrl (params))
00090               {
00091                 ww_value[0] += rw/* * this->mult*/;
00092                 wr_block[0] += (rr_block[p3_gas * 3 + 0]/* * this->mult*/);
00093                 wr_block[1] += (rr_block[p3_gas * 3 + 1]/* * this->mult*/);
00094                 wr_block[2] += (rr_block[p3_gas * 3 + 2]/* * this->mult*/);
00095               }
00096           }
00097         void
00098         update_wr (const sp_connection_t &c, item_t ww) const
00099           {
00100             c->get_wr_value ()[0] *= ww;
00101             c->get_wr_value ()[1] *= ww;
00102             c->get_wr_value ()[2] *= ww;
00103           }
00104         void
00105         apply_wefac (const sp_connection_t &c, params_t &params) const
00106         {
00107           array_ext <item_t> rw = c->get_rw_value ();
00108           item_t wefac = params.well_->exploitation_factor_;
00109 
00110           rw[0] = blue_sky::apply_wefac (rw[0], wefac);
00111           rw[1] = blue_sky::apply_wefac (rw[1], wefac);
00112           rw[2] = blue_sky::apply_wefac (rw[2], wefac);
00113         }
00114 
00115         void
00116         update_rate (const sp_connection_t &c, params_t &params) const
00117         {
00118           item_t ww_bw = (params.bw_value[0] / params.ww_value[0]);
00119 
00120           c->get_rate_value ()[0] -= c->get_rw_value () [0] * ww_bw;
00121           c->get_rate_value ()[1] -= c->get_rw_value () [1] * ww_bw;
00122           c->get_rate_value ()[2] -= c->get_rw_value () [2] * ww_bw;
00123         }
00124       };
00125 
00126     template <typename mobility_calc_t>
00127     struct compute_rate_deriv_2p_ow : public compute_deriv <mobility_calc_t>
00128       {
00129         GET_COMPUTE_DERIV_BASE_TYPES;
00130 
00131         compute_rate_deriv_2p_ow (const mobility_calc_t &mobility_calc)
00132             : base_t (mobility_calc)
00133         {
00134         }
00135 
00136         void
00137         oil_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00138           {
00139             array_ext <item_t> rw_block = c->get_rw_value ();
00140             array_ext <item_t> wr_block = c->get_wr_value ();
00141             array_ext <item_t> rr_block = c->get_rr_value ();
00142             array_ext <item_t> ww_value = params.ww_value;
00143             item_t rw                   = 0;
00144 
00145             if (mobility_calc_t::is_oil_injection (params))
00146               {
00147                 rw = rw_block [p2ow_oil] = /*this->mult * */base_t::compute_oil_pref_deriv (data, params);
00148               }
00149             if (mobility_calc_t::is_o_ctrl (params))
00150               {
00151                 ww_value[0] += rw/* * this->mult*/;
00152                 wr_block[0] += (rr_block[p2ow_oil * 2 + 0]/* * this->mult*/);
00153                 wr_block[1] += (rr_block[p2ow_oil * 2 + 1]/* * this->mult*/);
00154               }
00155           }
00156         void
00157         water_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00158           {
00159             array_ext <item_t> rw_block = c->get_rw_value ();
00160             array_ext <item_t> wr_block = c->get_wr_value ();
00161             array_ext <item_t> rr_block = c->get_rr_value ();
00162             array_ext <item_t> ww_value = params.ww_value;
00163             item_t rw                   = 0;
00164 
00165             if (mobility_calc_t::is_water_injection (params))
00166               {
00167                 rw = rw_block [p2ow_wat] = /*this->mult * */base_t::compute_water_pref_deriv (data, params);
00168               }
00169             if (mobility_calc_t::is_w_ctrl (params))
00170               {
00171                 ww_value[0] += rw/* * this->mult*/;
00172                 wr_block[0] += (rr_block[p2ow_wat * 2 + 0]/* * this->mult*/);
00173                 wr_block[1] += (rr_block[p2ow_wat * 2 + 1]/* * this->mult*/);
00174               }
00175           }
00176         void
00177         gas_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00178           {
00179           }
00180         void
00181         update_wr (const sp_connection_t &c, item_t ww) const
00182           {
00183             c->get_wr_value ()[0] *= ww;
00184             c->get_wr_value ()[1] *= ww;
00185           }
00186         void
00187         apply_wefac (const sp_connection_t &c, params_t &params) const
00188         {
00189           array_ext <item_t> rw = c->get_rw_value ();
00190           item_t wefac = params.well_->exploitation_factor_;
00191 
00192           rw[0] = blue_sky::apply_wefac (rw[0], wefac);
00193           rw[1] = blue_sky::apply_wefac (rw[1], wefac);
00194         }
00195         void
00196         update_rate (const sp_connection_t &c, params_t &params) const
00197         {
00198           item_t ww_bw = (params.bw_value[0] / params.ww_value[0]);
00199 
00200           c->get_rate_value ()[0] -= c->get_rw_value () [0] * ww_bw;
00201           c->get_rate_value ()[1] -= c->get_rw_value () [1] * ww_bw;
00202         }
00203       };
00204 
00205     template <typename mobility_calc_t>
00206     struct compute_rate_deriv_2p_og : public compute_deriv <mobility_calc_t>
00207       {
00208         GET_COMPUTE_DERIV_BASE_TYPES;
00209 
00210         compute_rate_deriv_2p_og (const mobility_calc_t &mobility_calc)
00211             : base_t (mobility_calc)
00212         {
00213         }
00214 
00215         void
00216         oil_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00217           {
00218             array_ext <item_t> rw_block = c->get_rw_value ();
00219             array_ext <item_t> wr_block = c->get_wr_value ();
00220             array_ext <item_t> rr_block = c->get_rr_value ();
00221             array_ext <item_t> ww_value = params.ww_value;
00222             item_t rw                   = 0;
00223 
00224             if (mobility_calc_t::is_oil_injection (params))
00225               {
00226                 rw = rw_block [p2og_oil] = /*this->mult * */base_t::compute_oil_pref_deriv (data, params);
00227               }
00228             if (mobility_calc_t::is_o_ctrl (params))
00229               {
00230                 ww_value[0] += rw/* * this->mult*/;
00231                 wr_block[0] += (rr_block[p2og_oil * 2 + 0]/* * this->mult*/);
00232                 wr_block[1] += (rr_block[p2og_oil * 2 + 1]/* * this->mult*/);
00233               }
00234           }
00235         void
00236         water_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00237           {
00238           }
00239         void
00240         gas_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00241           {
00242             array_ext <item_t> rw_block = c->get_rw_value ();
00243             array_ext <item_t> wr_block = c->get_wr_value ();
00244             array_ext <item_t> rr_block = c->get_rr_value ();
00245             array_ext <item_t> ww_value = params.ww_value;
00246             item_t rw                   = 0;
00247 
00248             if (mobility_calc_t::is_gas_injection (params))
00249               {
00250                 rw = rw_block [p2og_gas] = /*this->mult * */base_t::compute_gas_pref_deriv (data, params);
00251               }
00252             if (mobility_calc_t::is_g_ctrl (params))
00253               {
00254                 ww_value[0] += rw/* * this->mult*/;
00255                 wr_block[0] += (rr_block[p2og_gas * 2 + 0]/* * this->mult*/);
00256                 wr_block[1] += (rr_block[p2og_gas * 2 + 1]/* * this->mult*/);
00257               }
00258           }
00259         void
00260         update_wr (const sp_connection_t &c, item_t ww) const
00261           {
00262             c->get_wr_value ()[0] *= ww;
00263             c->get_wr_value ()[1] *= ww;
00264           }
00265         void
00266         apply_wefac (const sp_connection_t &c, params_t &params) const
00267         {
00268           array_ext <item_t> rw = c->get_rw_value ();
00269           item_t wefac = params.well_->exploitation_factor_;
00270 
00271           rw[0] = blue_sky::apply_wefac (rw[0], wefac);
00272           rw[1] = blue_sky::apply_wefac (rw[1], wefac);
00273         }
00274         void
00275         update_rate (const sp_connection_t &c, params_t &params) const
00276         {
00277           item_t ww_bw = (params.bw_value[0] / params.ww_value[0]);
00278 
00279           c->get_rate_value ()[0] -= c->get_rw_value () [0] * ww_bw;
00280           c->get_rate_value ()[1] -= c->get_rw_value () [1] * ww_bw;
00281         }
00282       };
00283 
00284     template <typename mobility_calc_t>
00285     struct compute_rate_deriv_1p_o : public compute_deriv <mobility_calc_t>
00286       {
00287         GET_COMPUTE_DERIV_BASE_TYPES;
00288 
00289         compute_rate_deriv_1p_o (const mobility_calc_t &mobility_calc)
00290             : base_t (mobility_calc)
00291         {
00292         }
00293 
00294         void
00295         oil_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00296           {
00297             array_ext <item_t> rw_block = c->get_rw_value ();
00298             array_ext <item_t> wr_block = c->get_wr_value ();
00299             array_ext <item_t> rr_block = c->get_rr_value ();
00300             array_ext <item_t> ww_value = params.ww_value;
00301             item_t rw                   = 0;
00302 
00303             if (mobility_calc_t::is_oil_injection (params))
00304               {
00305                 rw = rw_block [0] = /*this->mult * */base_t::compute_oil_pref_deriv (data, params);
00306               }
00307             if (mobility_calc_t::is_o_ctrl (params))
00308               {
00309                 ww_value[0] += rw/* * this->mult*/;
00310                 wr_block[0] += (rr_block[0]/* * this->mult*/);
00311               }
00312           }
00313         void
00314         water_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00315           {
00316           }
00317         void
00318         gas_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00319           {
00320           }
00321         void
00322         update_wr (const sp_connection_t &c, item_t ww) const
00323           {
00324             c->get_wr_value ()[0] *= ww;
00325           }
00326         void
00327         apply_wefac (const sp_connection_t &c, params_t &params) const
00328         {
00329           array_ext <item_t> rw = c->get_rw_value ();
00330           item_t wefac = params.well_->exploitation_factor_;
00331 
00332           rw[0] = blue_sky::apply_wefac (rw[0], wefac);
00333         }
00334         void
00335         update_rate (const sp_connection_t &c, params_t &params) const
00336         {
00337           item_t ww_bw = (params.bw_value[0] / params.ww_value[0]);
00338 
00339           c->get_rate_value ()[0] -= c->get_rw_value () [0] * ww_bw;
00340         }
00341       };
00342     template <typename mobility_calc_t>
00343     struct compute_rate_deriv_1p_w : public compute_deriv <mobility_calc_t>
00344       {
00345         GET_COMPUTE_DERIV_BASE_TYPES;
00346 
00347         compute_rate_deriv_1p_w (const mobility_calc_t &mobility_calc)
00348             : base_t (mobility_calc)
00349         {
00350         }
00351 
00352         void
00353         oil_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00354           {
00355           }
00356         void
00357         water_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00358           {
00359             array_ext <item_t> rw_block = c->get_rw_value ();
00360             array_ext <item_t> wr_block = c->get_wr_value ();
00361             array_ext <item_t> rr_block = c->get_rr_value ();
00362             array_ext <item_t> ww_value = params.ww_value;
00363             item_t rw                   = 0;
00364 
00365             if (mobility_calc_t::is_water_injection (params))
00366               {
00367                 rw = rw_block [0] = /*this->mult * */base_t::compute_water_pref_deriv (data, params);
00368               }
00369             if (mobility_calc_t::is_w_ctrl (params))
00370               {
00371                 ww_value[0] += rw/* * this->mult*/;
00372                 wr_block[0] += (rr_block[0]/* * this->mult*/);
00373               }
00374           }
00375         void
00376         gas_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00377           {
00378           }
00379         void
00380         update_wr (const sp_connection_t &c, item_t ww) const
00381           {
00382             c->get_wr_value ()[0] *= ww;
00383           }
00384         void
00385         apply_wefac (const sp_connection_t &c, params_t &params) const
00386         {
00387           array_ext <item_t> rw = c->get_rw_value ();
00388           item_t wefac = params.well_->exploitation_factor_;
00389 
00390           rw[0] = blue_sky::apply_wefac (rw[0], wefac);
00391         }
00392         void
00393         update_rate (const sp_connection_t &c, params_t &params) const
00394         {
00395           item_t ww_bw = (params.bw_value[0] / params.ww_value[0]);
00396 
00397           c->get_rate_value ()[0] -= c->get_rw_value () [0] * ww_bw;
00398         }
00399       };
00400     template <typename mobility_calc_t>
00401     struct compute_rate_deriv_1p_g : public compute_deriv <mobility_calc_t>
00402     {
00403       GET_COMPUTE_DERIV_BASE_TYPES;
00404 
00405       compute_rate_deriv_1p_g (const mobility_calc_t &mobility_calc)
00406           : base_t (mobility_calc)
00407       {
00408       }
00409 
00410       void
00411       oil_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00412       {
00413       }
00414       void
00415       water_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00416       {
00417       }
00418       void
00419       gas_function (const sp_connection_t &c, const data_t &data, params_t &params) const
00420       {
00421         array_ext <item_t> rw_block = c->get_rw_value ();
00422         array_ext <item_t> wr_block = c->get_wr_value ();
00423         array_ext <item_t> rr_block = c->get_rr_value ();
00424         array_ext <item_t> ww_value = params.ww_value;
00425         item_t rw                   = 0;
00426 
00427         if (mobility_calc_t::is_gas_injection (params))
00428           {
00429             rw = rw_block [0] = /*this->mult * */base_t::compute_gas_pref_deriv (data, params);
00430           }
00431         if (mobility_calc_t::is_g_ctrl (params))
00432           {
00433             ww_value[0] += rw/* * this->mult*/;
00434             wr_block[0] += (rr_block[0]/* * this->mult*/);
00435           }
00436       }
00437       void
00438       update_wr (const sp_connection_t &c, item_t ww) const
00439       {
00440         c->get_wr_value ()[0] *= ww;
00441       }
00442       void
00443       apply_wefac (const sp_connection_t &c, params_t &params) const
00444       {
00445         array_ext <item_t> rw = c->get_rw_value ();
00446         item_t wefac = params.well_->exploitation_factor_;
00447 
00448         rw[0] = blue_sky::apply_wefac (rw[0], wefac);
00449       }
00450       void
00451       update_rate (const sp_connection_t &c, params_t &params) const
00452       {
00453         item_t ww_bw = (params.bw_value[0] / params.ww_value[0]);
00454 
00455         c->get_rate_value ()[0] -= c->get_rw_value () [0] * ww_bw;
00456       }
00457     };
00458 
00459 
00460 
00461   } // namespace wells
00462 } // namespace blue_sky
00463 
00464 #endif  // #ifndef BS_WELLS_WELL_RATE_CONTROL_RATE_DERIV_H_
00465
well_rate_control_rate_deriv.h
