void TransportSolverCompressibleTwophaseReorder::initGravity(const double* grav) { // Set up transmissibilities. std::vector<double> htrans(grid_.cell_facepos[grid_.number_of_cells]); const int nf = grid_.number_of_faces; trans_.resize(nf); gravflux_.resize(nf); tpfa_htrans_compute(const_cast<UnstructuredGrid*>(&grid_), props_.permeability(), &htrans[0]); tpfa_trans_compute(const_cast<UnstructuredGrid*>(&grid_), &htrans[0], &trans_[0]); // Remember gravity vector. gravity_ = grav; }
int fits_hcompress(int *a, int ny, int nx, int scale, char *output, long *nbytes, int *status) { /* compress the input image using the H-compress algorithm a - input image array nx - size of X axis of image ny - size of Y axis of image scale - quantization scale factor. Larger values results in more (lossy) compression scale = 0 does lossless compression output - pre-allocated array to hold the output compressed stream of bytes nbyts - input value = size of the output buffer; returned value = size of the compressed byte stream, in bytes NOTE: the nx and ny dimensions as defined within this code are reversed from the usual FITS notation. ny is the fastest varying dimension, which is usually considered the X axis in the FITS image display */ int stat; if (*status > 0) return(*status); /* H-transform */ stat = htrans(a, nx, ny); if (stat) { *status = stat; return(*status); } /* digitize */ digitize(a, nx, ny, scale); /* encode and write to output array */ FFLOCK; noutmax = *nbytes; /* input value is the allocated size of the array */ *nbytes = 0; /* reset */ stat = encode(output, nbytes, a, nx, ny, scale); FFUNLOCK; *status = stat; return(*status); }
DerivedGeology(const UnstructuredGrid& grid, const Props& props , const double* grav = 0) : pvol_ (grid.number_of_cells) , trans_(grid.number_of_faces) , gpot_ (Vector::Zero(grid.cell_facepos[ grid.number_of_cells ], 1)) { // Pore volume const typename Vector::Index nc = grid.number_of_cells; std::transform(grid.cell_volumes, grid.cell_volumes + nc, props.porosity(), pvol_.data(), std::multiplies<double>()); // Transmissibility Vector htrans(grid.cell_facepos[nc]); UnstructuredGrid* ug = const_cast<UnstructuredGrid*>(& grid); tpfa_htrans_compute(ug, props.permeability(), htrans.data()); tpfa_trans_compute (ug, htrans.data() , trans_.data()); // Gravity potential std::fill(gravity_, gravity_ + 3, 0.0); if (grav != 0) { const typename Vector::Index nd = grid.dimensions; for (typename Vector::Index c = 0; c < nc; ++c) { const double* const cc = & grid.cell_centroids[c*nd + 0]; const int* const p = grid.cell_facepos; for (int i = p[c]; i < p[c + 1]; ++i) { const int f = grid.cell_faces[i]; const double* const fc = & grid.face_centroids[f*nd + 0]; for (typename Vector::Index d = 0; d < nd; ++d) { gpot_[i] += grav[d] * (fc[d] - cc[d]); } } } std::copy(grav, grav + nd, gravity_); } }
void TransportSolverTwophaseReorder::initGravity(const double* grav) { // Set up gravflux_ = T_ij g (rho_w - rho_o) (z_i - z_j) std::vector<double> htrans(grid_.cell_facepos[grid_.number_of_cells]); const int nf = grid_.number_of_faces; const int dim = grid_.dimensions; gravflux_.resize(nf); tpfa_htrans_compute(const_cast<UnstructuredGrid*>(&grid_), props_.permeability(), &htrans[0]); tpfa_trans_compute(const_cast<UnstructuredGrid*>(&grid_), &htrans[0], &gravflux_[0]); const double delta_rho = props_.density()[0] - props_.density()[1]; for (int f = 0; f < nf; ++f) { const int* c = &grid_.face_cells[2*f]; double gdz = 0.0; if (c[0] != -1 && c[1] != -1) { for (int d = 0; d < dim; ++d) { gdz += grav[d]*(grid_.cell_centroids[dim*c[0] + d] - grid_.cell_centroids[dim*c[1] + d]); } } gravflux_[f] *= delta_rho*gdz; } }