00001
00010 #ifndef BS_WELLS_WELL_RATE_CONTROL_BHP_DERIV_H_
00011 #define BS_WELLS_WELL_RATE_CONTROL_BHP_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_bhp_deriv_3p : public compute_deriv <mobility_calc_t>
00023 {
00024 GET_COMPUTE_DERIV_BASE_TYPES;
00025
00026 compute_bhp_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 ¶ms) const
00033 {
00034 if (mobility_calc_t::is_oil_injection (params))
00035 {
00036 array_ext <item_t> rr_block = c->get_rr_value ();
00037 array_ext <item_t> ps_block = c->get_ps_value ();
00038
00039 ps_block [p3_oil] = base_t::compute_oil_sw_deriv (data, params);
00040 rr_block [p3_oil_po] = base_t::compute_oil_po_deriv (data, params);
00041 rr_block [p3_oil_so] = base_t::compute_oil_so_deriv (data, params);
00042 rr_block [p3_oil_sg] = base_t::compute_oil_sg_deriv (data, params);
00043 }
00044 }
00045 void
00046 water_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00047 {
00048 if (mobility_calc_t::is_water_injection (params))
00049 {
00050 array_ext <item_t> rr_block = c->get_rr_value ();
00051 array_ext <item_t> ps_block = c->get_ps_value ();
00052
00053 ps_block [p3_wat] = base_t::compute_water_sw_deriv (data, params);
00054 rr_block [p3_wat_po] = base_t::compute_water_po_deriv (data, params);
00055 rr_block [p3_wat_so] = base_t::compute_water_so_deriv (data, params);
00056 rr_block [p3_wat_sg] = base_t::compute_water_sg_deriv (data, params);
00057 }
00058 }
00059 void
00060 gas_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00061 {
00062 if (mobility_calc_t::is_gas_injection (params))
00063 {
00064 array_ext <item_t> rr_block = c->get_rr_value ();
00065 array_ext <item_t> ps_block = c->get_ps_value ();
00066
00067 ps_block [p3_gas] = base_t::compute_gas_sw_deriv (data, params);
00068 rr_block [p3_gas_po] = base_t::compute_gas_po_deriv (data, params);
00069 rr_block [p3_gas_so] = base_t::compute_gas_so_deriv (data, params);
00070 rr_block [p3_gas_sg] = base_t::compute_gas_sg_deriv (data, params);
00071 }
00072 }
00073
00074 void
00075 update_rr (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00076 {
00077 array_ext <item_t> rr = c->get_rr_value ();
00078 array_ext <item_t> ps = c->get_ps_value ();
00079 const rhs_item_t *sp = ¶ms.jmatrix_->get_sp_diagonal ()[params.n_block * params.n_phases];
00080
00081 M_MINUS_VV_PROD_3x3 (ps, sp, rr);
00082 }
00083 void
00084 update_rhs_flux (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00085 {
00086 array_ext <item_t> ps = c->get_ps_value ();
00087 const rhs_item_t *s_rhs_block = ¶ms.jmatrix_->get_sec_rhs ()[params.calc_model_->n_sec_vars * params.n_block];
00088 array_ext <rhs_item_t> r_rhs_block = c->get_rate_value ();
00089
00090 V_MINUS_VS_PROD_3x3 (ps, s_rhs_block, r_rhs_block);
00091 }
00092
00093 void
00094 compute_bw_value (params_t ¶ms) const
00095 {
00096 params.bw_value[0] = 0;
00097
00098 if (mobility_calc_t::is_o_ctrl (params) && mobility_calc_t::is_w_ctrl (params))
00099 {
00100 if (params.is_prod)
00101 params.bw_value[0] += (params.rate.prod.oil + params.rate.prod.water) - this->mult * params.limit_rate.prod.liquid;
00102 else
00103 params.bw_value[0] += (params.rate.inj.oil + params.rate.inj.water) - this->mult * params.limit_rate.inj.liquid;
00104 }
00105 else
00106 {
00107 if (mobility_calc_t::is_o_ctrl (params))
00108 {
00109 if (params.is_prod)
00110 params.bw_value[0] += params.rate.prod.oil - this->mult * params.limit_rate.prod.oil;
00111 else
00112 params.bw_value[0] += params.rate.inj.oil - this->mult * params.limit_rate.inj.oil;
00113 }
00114
00115 if (mobility_calc_t::is_w_ctrl (params))
00116 {
00117 if (params.is_prod)
00118 params.bw_value[0] += params.rate.prod.water - this->mult * params.limit_rate.prod.water;
00119 else
00120 params.bw_value[0] += params.rate.inj.water - this->mult * params.limit_rate.inj.water;
00121 }
00122
00123 if (mobility_calc_t::is_g_ctrl (params))
00124 {
00125 if (params.is_prod)
00126 params.bw_value[0] += params.rate.prod.gas - this->mult * params.limit_rate.prod.gas;
00127 else
00128 params.bw_value[0] += params.rate.inj.gas - this->mult * params.limit_rate.inj.gas;
00129 }
00130 }
00131 }
00132 void
00133 apply_wefac (const sp_connection_t &c, params_t ¶ms) const
00134 {
00135 array_ext <item_t> rr = c->get_rr_value ();
00136 item_t wefac = params.well_->exploitation_factor_;
00137
00138 rr[0] = blue_sky::apply_wefac (rr[0], wefac);
00139 rr[1] = blue_sky::apply_wefac (rr[1], wefac);
00140 rr[2] = blue_sky::apply_wefac (rr[2], wefac);
00141 rr[3] = blue_sky::apply_wefac (rr[3], wefac);
00142 rr[4] = blue_sky::apply_wefac (rr[4], wefac);
00143 rr[5] = blue_sky::apply_wefac (rr[5], wefac);
00144 rr[6] = blue_sky::apply_wefac (rr[6], wefac);
00145 rr[7] = blue_sky::apply_wefac (rr[7], wefac);
00146 rr[8] = blue_sky::apply_wefac (rr[8], wefac);
00147 }
00148 };
00149
00150 template <typename mobility_calc_t>
00151 struct compute_bhp_deriv_2p_ow : public compute_deriv <mobility_calc_t>
00152 {
00153 GET_COMPUTE_DERIV_BASE_TYPES;
00154
00155 compute_bhp_deriv_2p_ow (const mobility_calc_t &mobility_calc)
00156 : base_t (mobility_calc)
00157 {
00158 }
00159
00160 void
00161 oil_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00162 {
00163 if (mobility_calc_t::is_oil_injection (params))
00164 {
00165 array_ext <item_t> rr_block = c->get_rr_value ();
00166 array_ext <item_t> ps_block = c->get_ps_value ();
00167
00168 ps_block [p2ow_oil] = base_t::compute_oil_sw_deriv (data, params);
00169 rr_block [p2ow_oil_po] = base_t::compute_oil_po_deriv (data, params);
00170 rr_block [p2ow_oil_so] = base_t::compute_oil_so_deriv (data, params);
00171 }
00172 }
00173 void
00174 water_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00175 {
00176 if (mobility_calc_t::is_water_injection (params))
00177 {
00178 array_ext <item_t> rr_block = c->get_rr_value ();
00179 array_ext <item_t> ps_block = c->get_ps_value ();
00180
00181 ps_block [p2ow_wat] = base_t::compute_water_sw_deriv (data, params);
00182 rr_block [p2ow_wat_po] = base_t::compute_water_po_deriv (data, params);
00183 rr_block [p2ow_wat_so] = base_t::compute_water_so_deriv (data, params);
00184 }
00185 }
00186 void
00187 gas_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00188 {
00189 }
00190
00191 void
00192 update_rr (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00193 {
00194 array_ext <item_t> rr = c->get_rr_value ();
00195 array_ext <item_t> ps = c->get_ps_value ();
00196 const rhs_item_t *sp = ¶ms.jmatrix_->get_sp_diagonal ()[params.n_block * params.n_phases];
00197
00198 M_MINUS_VV_PROD_2x2 (ps, sp, rr);
00199 }
00200 void
00201 update_rhs_flux (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00202 {
00203 array_ext <item_t> ps = c->get_ps_value ();
00204 const rhs_item_t *s_rhs_block = ¶ms.jmatrix_->get_sec_rhs ()[params.calc_model_->n_sec_vars * params.n_block];
00205 array_ext <rhs_item_t> r_rhs_block = c->get_rate_value ();
00206
00207 V_MINUS_VS_PROD_2x2 (ps, s_rhs_block, r_rhs_block);
00208 }
00209 void
00210 compute_bw_value (params_t ¶ms) const
00211 {
00212 params.bw_value[0] = 0;
00213
00214 if (mobility_calc_t::is_o_ctrl (params))
00215 {
00216 if (params.is_prod)
00217 params.bw_value[0] += params.rate.prod.oil - this->mult * params.limit_rate.prod.oil;
00218 else
00219 params.bw_value[0] += params.rate.inj.oil - this->mult * params.limit_rate.inj.oil;
00220 }
00221
00222 if (mobility_calc_t::is_w_ctrl (params))
00223 {
00224 if (params.is_prod)
00225 params.bw_value[0] += params.rate.prod.water - this->mult * params.limit_rate.prod.water;
00226 else
00227 params.bw_value[0] += params.rate.inj.water - this->mult * params.limit_rate.inj.water;
00228 }
00229 }
00230 void
00231 apply_wefac (const sp_connection_t &c, params_t ¶ms) const
00232 {
00233 array_ext <item_t> rr = c->get_rr_value ();
00234 item_t wefac = params.well_->exploitation_factor_;
00235
00236 rr[0] = blue_sky::apply_wefac (rr[0], wefac);
00237 rr[1] = blue_sky::apply_wefac (rr[1], wefac);
00238 rr[2] = blue_sky::apply_wefac (rr[2], wefac);
00239 rr[3] = blue_sky::apply_wefac (rr[3], wefac);
00240 }
00241 };
00242
00243 template <typename mobility_calc_t>
00244 struct compute_bhp_deriv_2p_og : public compute_deriv <mobility_calc_t>
00245 {
00246 GET_COMPUTE_DERIV_BASE_TYPES;
00247
00248 compute_bhp_deriv_2p_og (const mobility_calc_t &mobility_calc)
00249 : base_t (mobility_calc)
00250 {
00251 }
00252
00253 void
00254 oil_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00255 {
00256 if (mobility_calc_t::is_oil_injection (params))
00257 {
00258 array_ext <item_t> rr_block = c->get_rr_value ();
00259 array_ext <item_t> ps_block = c->get_ps_value ();
00260
00261 ps_block [p2og_oil] = base_t::compute_oil_so_deriv (data, params);
00262 rr_block [p2og_oil_po] = base_t::compute_oil_po_deriv (data, params);
00263 rr_block [p2og_oil_sg] = base_t::compute_oil_sg_deriv (data, params);
00264 }
00265 }
00266 void
00267 water_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00268 {
00269 }
00270 void
00271 gas_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00272 {
00273 if (mobility_calc_t::is_gas_injection (params))
00274 {
00275 array_ext <item_t> rr_block = c->get_rr_value ();
00276 array_ext <item_t> ps_block = c->get_ps_value ();
00277
00278 ps_block [p2og_gas] = base_t::compute_gas_so_deriv (data, params);
00279 rr_block [p2og_gas_po] = base_t::compute_gas_po_deriv (data, params);
00280 rr_block [p2og_gas_sg] = base_t::compute_gas_sg_deriv (data, params);
00281 }
00282 }
00283
00284 void
00285 update_rr (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00286 {
00287 array_ext <item_t> rr = c->get_rr_value ();
00288 array_ext <item_t> ps = c->get_ps_value ();
00289 const rhs_item_t *sp = ¶ms.jmatrix_->get_sp_diagonal ()[params.n_block * params.n_phases];
00290
00291 M_MINUS_VV_PROD_2x2 (ps, sp, rr);
00292 }
00293 void
00294 update_rhs_flux (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00295 {
00296 array_ext <item_t> ps = c->get_ps_value ();
00297 const rhs_item_t *s_rhs_block = ¶ms.jmatrix_->get_sec_rhs ()[params.calc_model_->n_sec_vars * params.n_block];
00298 array_ext <rhs_item_t> r_rhs_block = c->get_rate_value ();
00299
00300 V_MINUS_VS_PROD_2x2 (ps, s_rhs_block, r_rhs_block);
00301 }
00302 void
00303 compute_bw_value (params_t ¶ms) const
00304 {
00305 params.bw_value[0] = 0;
00306
00307 if (mobility_calc_t::is_o_ctrl (params))
00308 {
00309 if (params.is_prod)
00310 params.bw_value[0] += params.rate.prod.oil - this->mult * params.limit_rate.prod.oil;
00311 else
00312 params.bw_value[0] += params.rate.inj.oil - this->mult * params.limit_rate.inj.oil;
00313 }
00314
00315 if (mobility_calc_t::is_g_ctrl (params))
00316 {
00317 if (params.is_prod)
00318 params.bw_value[0] += params.rate.prod.gas - this->mult * params.limit_rate.prod.gas;
00319 else
00320 params.bw_value[0] += params.rate.inj.gas - this->mult * params.limit_rate.inj.gas;
00321 }
00322 }
00323 void
00324 apply_wefac (const sp_connection_t &c, params_t ¶ms) const
00325 {
00326 array_ext <item_t> rr = c->get_rr_value ();
00327 item_t wefac = params.well_->exploitation_factor_;
00328
00329 rr[0] = blue_sky::apply_wefac (rr[0], wefac);
00330 rr[1] = blue_sky::apply_wefac (rr[1], wefac);
00331 rr[2] = blue_sky::apply_wefac (rr[2], wefac);
00332 rr[3] = blue_sky::apply_wefac (rr[3], wefac);
00333 }
00334 };
00335
00336 template <typename mobility_calc_t>
00337 struct compute_bhp_deriv_1p_o : public compute_deriv <mobility_calc_t>
00338 {
00339 GET_COMPUTE_DERIV_BASE_TYPES;
00340
00341 compute_bhp_deriv_1p_o (const mobility_calc_t &mobility_calc)
00342 : base_t (mobility_calc)
00343 {
00344 }
00345
00346 void
00347 oil_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00348 {
00349 if (mobility_calc_t::is_oil_injection (params))
00350 {
00351 array_ext <item_t> rr_block = c->get_rr_value ();
00352 rr_block [0] = base_t::compute_oil_po_deriv (data, params);
00353 }
00354 }
00355 void
00356 water_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00357 {
00358 }
00359 void
00360 gas_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00361 {
00362 }
00363
00364 void
00365 update_rr (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00366 {
00367 }
00368 void
00369 update_rhs_flux (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00370 {
00371 array_ext <item_t> ps = c->get_ps_value ();
00372 const rhs_item_t *s_rhs_block = ¶ms.jmatrix_->get_sec_rhs ()[params.calc_model_->n_sec_vars * params.n_block];
00373 array_ext <rhs_item_t> r_rhs_block = c->get_rate_value ();
00374
00375 V_MINUS_VS_PROD_1x1 (ps, s_rhs_block, r_rhs_block);
00376 }
00377 void
00378 compute_bw_value (params_t ¶ms) const
00379 {
00380 BS_ASSERT (mobility_calc_t::is_o_ctrl (params));
00381
00382 if (params.is_prod)
00383 params.bw_value[0] += params.rate.prod.oil - this->mult * params.limit_rate.prod.oil;
00384 else
00385 params.bw_value[0] += params.rate.inj.oil - this->mult * params.limit_rate.inj.oil;
00386 }
00387 void
00388 apply_wefac (const sp_connection_t &c, params_t ¶ms) const
00389 {
00390 array_ext <item_t> rr = c->get_rr_value ();
00391 item_t wefac = params.well_->exploitation_factor_;
00392
00393 rr[0] = blue_sky::apply_wefac (rr[0], wefac);
00394 }
00395 };
00396 template <typename mobility_calc_t>
00397 struct compute_bhp_deriv_1p_w : public compute_deriv <mobility_calc_t>
00398 {
00399 GET_COMPUTE_DERIV_BASE_TYPES;
00400
00401 compute_bhp_deriv_1p_w (const mobility_calc_t &mobility_calc)
00402 : base_t (mobility_calc)
00403 {
00404 }
00405
00406 void
00407 oil_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00408 {
00409 }
00410 void
00411 water_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00412 {
00413 if (mobility_calc_t::is_water_injection (params))
00414 {
00415 array_ext <item_t> rr_block = c->get_rr_value ();
00416 rr_block [0] = base_t::compute_water_po_deriv (data, params);
00417 }
00418 }
00419 void
00420 gas_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00421 {
00422 }
00423
00424 void
00425 update_rr (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00426 {
00427 }
00428 void
00429 update_rhs_flux (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00430 {
00431 array_ext <item_t> ps = c->get_ps_value ();
00432 const rhs_item_t *s_rhs_block = ¶ms.jmatrix_->get_sec_rhs ()[params.calc_model_->n_sec_vars * params.n_block];
00433 array_ext <rhs_item_t> r_rhs_block = c->get_rate_value ();
00434
00435 V_MINUS_VS_PROD_1x1 (ps, s_rhs_block, r_rhs_block);
00436 }
00437 void
00438 compute_bw_value (params_t ¶ms) const
00439 {
00440 BS_ASSERT (mobility_calc_t::is_w_ctrl (params));
00441
00442 if (params.is_prod)
00443 params.bw_value[0] += params.rate.prod.water - this->mult * params.limit_rate.prod.water;
00444 else
00445 params.bw_value[0] += params.rate.inj.water - this->mult * params.limit_rate.inj.water;
00446 }
00447 void
00448 apply_wefac (const sp_connection_t &c, params_t ¶ms) const
00449 {
00450 array_ext <item_t> rr = c->get_rr_value ();
00451 item_t wefac = params.well_->exploitation_factor_;
00452
00453 rr[0] = blue_sky::apply_wefac (rr[0], wefac);
00454 }
00455 };
00456 template <typename mobility_calc_t>
00457 struct compute_bhp_deriv_1p_g : public compute_deriv <mobility_calc_t>
00458 {
00459 GET_COMPUTE_DERIV_BASE_TYPES;
00460
00461 compute_bhp_deriv_1p_g (const mobility_calc_t &mobility_calc)
00462 : base_t (mobility_calc)
00463 {
00464 }
00465
00466 void
00467 oil_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00468 {
00469 }
00470 void
00471 water_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00472 {
00473 }
00474 void
00475 gas_function (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00476 {
00477 if (mobility_calc_t::is_gas_injection (params))
00478 {
00479 array_ext <item_t> rr_block = c->get_rr_value ();
00480 rr_block [0] = base_t::compute_gas_po_deriv (data, params);
00481 }
00482 }
00483
00484 void
00485 update_rr (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00486 {
00487 }
00488 void
00489 update_rhs_flux (const sp_connection_t &c, const data_t &data, params_t ¶ms) const
00490 {
00491 array_ext <item_t> ps = c->get_ps_value ();
00492 const rhs_item_t *s_rhs_block = ¶ms.jmatrix_->get_sec_rhs ()[params.calc_model_->n_sec_vars * params.n_block];
00493 array_ext <rhs_item_t> r_rhs_block = c->get_rate_value ();
00494
00495 V_MINUS_VS_PROD_1x1 (ps, s_rhs_block, r_rhs_block);
00496 }
00497 void
00498 compute_bw_value (params_t ¶ms) const
00499 {
00500 BS_ASSERT (mobility_calc_t::is_g_ctrl (params));
00501
00502 if (params.is_prod)
00503 params.bw_value[0] += params.rate.prod.gas - this->mult * params.limit_rate.prod.gas;
00504 else
00505 params.bw_value[0] += params.rate.inj.gas - this->mult * params.limit_rate.inj.gas;
00506 }
00507 void
00508 apply_wefac (const sp_connection_t &c, params_t ¶ms) const
00509 {
00510 array_ext <item_t> rr = c->get_rr_value ();
00511 item_t wefac = params.well_->exploitation_factor_;
00512
00513 rr[0] = blue_sky::apply_wefac (rr[0], wefac);
00514 }
00515 };
00516
00517 }
00518 }
00519
00520
00521 #endif // #ifndef BS_WELLS_WELL_RATE_CONTROL_BHP_DERIV_H_
00522
