/// Compute the output. void CompressibleTpfa::computeResults(BlackoilState& state, WellState& well_state) const { UnstructuredGrid* gg = const_cast<UnstructuredGrid*>(&grid_); CompletionData completion_data; completion_data.wdp = ! wellperf_wdp_.empty() ? const_cast<double*>(&wellperf_wdp_[0]) : 0; completion_data.A = ! wellperf_A_.empty() ? const_cast<double*>(&wellperf_A_[0]) : 0; completion_data.phasemob = ! wellperf_phasemob_.empty() ? const_cast<double*>(&wellperf_phasemob_[0]) : 0; cfs_tpfa_res_wells wells_tmp; wells_tmp.W = const_cast<Wells*>(wells_); wells_tmp.data = &completion_data; cfs_tpfa_res_forces forces; forces.wells = &wells_tmp; forces.src = NULL; double* wpress = ! well_state.bhp ().empty() ? & well_state.bhp ()[0] : 0; double* wflux = ! well_state.perfRates().empty() ? & well_state.perfRates()[0] : 0; cfs_tpfa_res_flux(gg, &forces, props_.numPhases(), &trans_[0], &cell_phasemob_[0], &face_phasemob_[0], &face_gravcap_[0], &state.pressure()[0], wpress, &state.faceflux()[0], wflux); cfs_tpfa_res_fpress(gg, props_.numPhases(), &htrans_[0], &face_phasemob_[0], &face_gravcap_[0], h_, &state.pressure()[0], &state.faceflux()[0], &state.facepressure()[0]); // Compute well perforation pressures (not done by the C code). if (wells_ != 0) { const int nw = wells_->number_of_wells; for (int w = 0; w < nw; ++w) { for (int j = wells_->well_connpos[w]; j < wells_->well_connpos[w+1]; ++j) { const double bhp = well_state.bhp()[w]; well_state.perfPress()[j] = bhp + wellperf_wdp_[j]; } } } }
bool equals(const BlackoilState& other, double epsilon = 1e-8) const { bool equal = (numPhases() == other.numPhases()); for (int phaseIdx = 0; phaseIdx < BlackoilPhases::MaxNumPhases; ++ phaseIdx) { equal = equal && (usedPhases_.phase_used[phaseIdx] == other.usedPhases_.phase_used[phaseIdx]); if (usedPhases_.phase_used[phaseIdx]) equal = equal && (usedPhases_.phase_pos[phaseIdx] == other.usedPhases_.phase_pos[phaseIdx]); } equal = equal && (vectorApproxEqual( pressure() , other.pressure() , epsilon)); equal = equal && (vectorApproxEqual( facepressure() , other.facepressure() , epsilon)); equal = equal && (vectorApproxEqual( faceflux() , other.faceflux() , epsilon)); equal = equal && (vectorApproxEqual( surfacevol() , other.surfacevol() , epsilon)); equal = equal && (vectorApproxEqual( saturation() , other.saturation() , epsilon)); equal = equal && (vectorApproxEqual( gasoilratio() , other.gasoilratio() , epsilon)); return equal; }
/// Compute per-iteration dynamic properties for faces. void CompressibleTpfa::computeFaceDynamicData(const double /*dt*/, const BlackoilState& state, const WellState& /*well_state*/) { // These are the variables that get computed by this function: // // std::vector<double> face_A_; // std::vector<double> face_phasemob_; // std::vector<double> face_gravcap_; const int np = props_.numPhases(); const int nf = grid_.number_of_faces; const int dim = grid_.dimensions; const double grav = gravity_ ? gravity_[dim - 1] : 0.0; std::vector<double> gravcontrib[2]; std::vector<double> pot[2]; gravcontrib[0].resize(np); gravcontrib[1].resize(np); pot[0].resize(np); pot[1].resize(np); face_A_.resize(nf*np*np); face_phasemob_.resize(nf*np); face_gravcap_.resize(nf*np); for (int face = 0; face < nf; ++face) { // Obtain properties from both sides of the face. const double face_depth = grid_.face_centroids[face*dim + dim - 1]; const int* c = &grid_.face_cells[2*face]; // Get pressures and compute gravity contributions, // to decide upwind directions. double c_press[2]; for (int j = 0; j < 2; ++j) { if (c[j] >= 0) { // Pressure c_press[j] = state.pressure()[c[j]]; // Gravity contribution, gravcontrib = rho*(face_z - cell_z) [per phase]. if (grav != 0.0) { const double depth_diff = face_depth - grid_.cell_centroids[c[j]*dim + dim - 1]; props_.density(1, &cell_A_[np*np*c[j]], &c[j], &gravcontrib[j][0]); for (int p = 0; p < np; ++p) { gravcontrib[j][p] *= depth_diff*grav; } } else { std::fill(gravcontrib[j].begin(), gravcontrib[j].end(), 0.0); } } else { // Pressures c_press[j] = state.facepressure()[face]; // Gravity contribution. std::fill(gravcontrib[j].begin(), gravcontrib[j].end(), 0.0); } } // Gravity contribution: // gravcapf = rho_1*g*(z_12 - z_1) - rho_2*g*(z_12 - z_2) // where _1 and _2 refers to two neigbour cells, z is the // z coordinate of the centroid, and z_12 is the face centroid. // Also compute the potentials. for (int phase = 0; phase < np; ++phase) { face_gravcap_[np*face + phase] = gravcontrib[0][phase] - gravcontrib[1][phase]; pot[0][phase] = c_press[0] + face_gravcap_[np*face + phase]; pot[1][phase] = c_press[1]; } // Now we can easily find the upwind direction for every phase, // we can also tell which boundary faces are inflow bdys. // Get upwind mobilities by phase. // Get upwind A matrix rows by phase. // NOTE: // We should be careful to upwind the R factors, // the B factors are not that vital. // z = Au = RB^{-1}u, // where (this example is for gas-oil) // R = [1 RgL; RoV 1], B = [BL 0 ; 0 BV] // (RgL is gas in Liquid phase, RoV is oil in Vapour phase.) // A = [1/BL RgL/BV; RoV/BL 1/BV] // This presents us with a dilemma, as V factors should be // upwinded according to V phase flow, same for L. What then // about the RgL/BV and RoV/BL numbers? // We give priority to R, and therefore upwind the rows of A // by phase (but remember, Fortran matrix ordering). // This prompts the question if we should split the matrix() // property method into formation volume and R-factor methods. for (int phase = 0; phase < np; ++phase) { int upwindc = -1; if (c[0] >=0 && c[1] >= 0) { upwindc = (pot[0][phase] < pot[1][phase]) ? c[1] : c[0]; } else { upwindc = (c[0] >= 0) ? c[0] : c[1]; } face_phasemob_[np*face + phase] = cell_phasemob_[np*upwindc + phase]; for (int p2 = 0; p2 < np; ++p2) { // Recall: column-major ordering. face_A_[np*np*face + phase + np*p2] = cell_A_[np*np*upwindc + phase + np*p2]; } } } }