OilfieldToolsNet/opm-core
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1) Move extra fields found in struct CornerpointGrid into struct UnstructuredGrid.

Browse Source 
2) Remove typedef grid_t
3) Remove struct CornerpointGrid.
4) handle fallout.
This commit is contained in:
Jostein R. Natvig 2012-02-01 14:56:38 +01:00
parent e577b74a48
commit fb99d7bdaf
32 changed files with 254 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
opm/core/grid.h
View File

@ -1,5 +1,5 @@
/*
Copyright 2010 SINTEF ICT, Applied Mathematics.
Copyright 2010, 2011, 2012 SINTEF ICT, Applied Mathematics.
This file is part of the Open Porous Media project (OPM).
@ -48,11 +48,14 @@ struct UnstructuredGrid {
double *cell_centroids;
double *cell_volumes;
int *global_cell;
int cartdims[3];
int *cell_facetag;
};
typedef struct UnstructuredGrid grid_t;
#ifdef __cplusplus
}
#endif

2
opm/core/pressure/cfsh.c
View File

@ -82,7 +82,7 @@ cfsh_assemble_grid(flowbc_t *bc,
* the well connections represented by 'W'. */
/* ---------------------------------------------------------------------- */
struct fsh_data *
cfsh_construct(grid_t *G, well_t *W)
cfsh_construct(struct UnstructuredGrid *G, well_t *W)
/* ---------------------------------------------------------------------- */
{
int nc, ngconn_tot;

2
opm/core/pressure/fsh.c
View File

@ -38,7 +38,7 @@
* substitution process, projected half-contact fluxes. */
/* ---------------------------------------------------------------------- */
void
fsh_press_flux(grid_t *G,
fsh_press_flux(struct UnstructuredGrid *G,
const double *Binv, const double *gpress,
struct fsh_data *h,
double *cpress, double *fflux,

6
opm/core/pressure/fsh.h
View File

@ -72,7 +72,7 @@ fsh_destroy(struct fsh_data *h);
* given grid and well pattern.
*/
struct fsh_data *
cfsh_construct(grid_t *G, well_t *W);
cfsh_construct(struct UnstructuredGrid *G, well_t *W);
@ -102,7 +102,7 @@ cfsh_assemble(flowbc_t *bc,
* @param W The wells
*/
struct fsh_data *
ifsh_construct(grid_t *G, well_t *W);
ifsh_construct(struct UnstructuredGrid *G, well_t *W);
@ -161,7 +161,7 @@ ifsh_assemble(flowbc_t *bc,
* @param wflux[out] \TODO
*/
void
fsh_press_flux(grid_t *G,
fsh_press_flux(struct UnstructuredGrid *G,
const double *Binv, const double *gpress,
struct fsh_data *h,
double *cpress, double *fflux,

4
opm/core/pressure/fsh_common_impl.c
View File

@ -136,7 +136,7 @@ fsh_impl_allocate_basic(size_t idata_sz, size_t ddata_sz)
/* Determine nnz (=sum(diff(facePos)^2)) and max(diff(facePos) for grid */
/* ---------------------------------------------------------------------- */
void
fsh_count_grid_dof(grid_t *G, int *max_ngdof, size_t *sum_ngdof2)
fsh_count_grid_dof(struct UnstructuredGrid *G, int *max_ngdof, size_t *sum_ngdof2)
/* ---------------------------------------------------------------------- */
{
int c, n;
@ -243,7 +243,7 @@ fsh_define_linsys_arrays(struct fsh_data *h)
/* ---------------------------------------------------------------------- */
void
fsh_compute_table_sz(grid_t *G, well_t *W, int max_ngconn,
fsh_compute_table_sz(struct UnstructuredGrid *G, well_t *W, int max_ngconn,
size_t *nnu, size_t *idata_sz, size_t *ddata_sz)
/* ---------------------------------------------------------------------- */
{

4
opm/core/pressure/fsh_common_impl.h
View File

@ -54,7 +54,7 @@ struct fsh_impl *
fsh_impl_allocate_basic(size_t idata_sz, size_t ddata_sz);
void
fsh_count_grid_dof(grid_t *G, int *max_ngdof, size_t *sum_ngdof2);
fsh_count_grid_dof(struct UnstructuredGrid *G, int *max_ngdof, size_t *sum_ngdof2);
int
fsh_impose_bc(int ndof,
@ -77,7 +77,7 @@ void
fsh_define_linsys_arrays(struct fsh_data *h);
void
fsh_compute_table_sz(grid_t *G, well_t *W, int max_ngconn,
fsh_compute_table_sz(struct UnstructuredGrid *G, well_t *W, int max_ngconn,
size_t *nnu, size_t *idata_sz, size_t *ddata_sz);
#endif /* OPM_FSH_COMMON_IMPL_HEADER_INCLUDED */

2
opm/core/pressure/ifsh.c
View File

@ -247,7 +247,7 @@ ifsh_assemble_well(flowbc_t *bc,
* the well connections represented by 'W'. */
/* ---------------------------------------------------------------------- */
struct fsh_data *
ifsh_construct(grid_t *G, well_t *W)
ifsh_construct(struct UnstructuredGrid *G, well_t *W)
/* ---------------------------------------------------------------------- */
{
int nc, ngconn_tot;

10
opm/core/pressure/mimetic/hybsys_global.c
View File

@ -59,7 +59,7 @@ deallocate_well_dofset(size_t nw, struct hash_set **wia)
* successful and NULL otherwise. */
/* ---------------------------------------------------------------------- */
static struct hash_set **
allocate_well_dofset(grid_t *G, well_t *W)
allocate_well_dofset(struct UnstructuredGrid *G, well_t *W)
/* ---------------------------------------------------------------------- */
{
int w, i, c, ok;
@ -100,7 +100,7 @@ allocate_well_dofset(grid_t *G, well_t *W)
* if applicable. */
/* ---------------------------------------------------------------------- */
static void
count_conn_per_row_grid(grid_t *G, struct CSRMatrix *A)
count_conn_per_row_grid(struct UnstructuredGrid *G, struct CSRMatrix *A)
/* ---------------------------------------------------------------------- */
{
int c, nc, *ia, *ja;
@ -132,7 +132,7 @@ count_conn_per_row_grid(grid_t *G, struct CSRMatrix *A)
* Returns 1 if successful, and zero otherwise. */
/* ---------------------------------------------------------------------- */
static int
count_conn_per_row_well(grid_t *G, well_t *W,
count_conn_per_row_well(struct UnstructuredGrid *G, well_t *W,
int *cwpos,
int *cwells,
struct hash_set **wia,
@ -201,7 +201,7 @@ fill_self_connections(struct CSRMatrix *A)
/* Fill self-to-other DOF connections (i.e., define 'ja') for grid. */
/* ---------------------------------------------------------------------- */
static void
fill_grid_connections(grid_t *G, struct CSRMatrix *A)
fill_grid_connections(struct UnstructuredGrid *G, struct CSRMatrix *A)
/* ---------------------------------------------------------------------- */
{
int c, i, j, n;
@ -269,7 +269,7 @@ fill_well_connections(int nf, int nw,
* otherwise. */
/* ---------------------------------------------------------------------- */
struct CSRMatrix *
hybsys_define_globconn(grid_t *G, well_t *W)
hybsys_define_globconn(struct UnstructuredGrid *G, well_t *W)
/* ---------------------------------------------------------------------- */
{
int nw, ok;

2
opm/core/pressure/mimetic/hybsys_global.h
View File

@ -29,7 +29,7 @@ extern "C" {
#include <opm/core/linalg/sparse_sys.h>
struct CSRMatrix *
hybsys_define_globconn(grid_t *G, well_t *W);
hybsys_define_globconn(struct UnstructuredGrid *G, well_t *W);
void

26
opm/core/pressure/msmfem/coarse_sys.c
View File

@ -196,7 +196,7 @@ bf_asm_data_deallocate(struct bf_asm_data *data)
/* ---------------------------------------------------------------------- */
static struct bf_asm_data *
bf_asm_data_allocate(grid_t *g,
bf_asm_data_allocate(struct UnstructuredGrid *g,
struct coarse_sys_meta *m)
/* ---------------------------------------------------------------------- */
{
@ -463,7 +463,7 @@ coarse_sys_meta_fill(int nc, const int *pgconn,
/* ---------------------------------------------------------------------- */
static struct coarse_sys_meta *
coarse_sys_meta_construct(grid_t *g, const int *p,
coarse_sys_meta_construct(struct UnstructuredGrid *g, const int *p,
struct coarse_topology *ct)
/* ---------------------------------------------------------------------- */
{
@ -489,7 +489,7 @@ coarse_sys_meta_construct(grid_t *g, const int *p,
#if USE_MIM_IP_SIMPLE
/* ---------------------------------------------------------------------- */
static double *
compute_fs_ip(grid_t *g, const double *perm,
compute_fs_ip(struct UnstructuredGrid *g, const double *perm,
const struct coarse_sys_meta *m)
/* ---------------------------------------------------------------------- */
{
@ -511,7 +511,7 @@ compute_fs_ip(grid_t *g, const double *perm,
#include <opm/core/pressure/tpfa/trans_tpfa.h>
/* ---------------------------------------------------------------------- */
static double *
compute_fs_ip(grid_t *g, const double *perm,
compute_fs_ip(struct UnstructuredGrid *g, const double *perm,
const struct coarse_sys_meta *m)
/* ---------------------------------------------------------------------- */
{
@ -674,7 +674,7 @@ normalize_weighting(size_t nc, size_t nb, const int *p, double *w)
* Returns valid ponter if successful and NULL if not. */
/* ---------------------------------------------------------------------- */
static double *
coarse_weight(grid_t *g, size_t nb,
coarse_weight(struct UnstructuredGrid *g, size_t nb,
const int *p,
struct coarse_sys_meta *m,
const double *perm, const double *src)
@ -926,7 +926,7 @@ set_csys_block_pointers(struct coarse_topology *ct,
/* ---------------------------------------------------------------------- */
static int
enumerate_local_dofs(size_t cf,
grid_t *g ,
struct UnstructuredGrid *g ,
struct coarse_topology *ct,
struct coarse_sys_meta *m)
/* ---------------------------------------------------------------------- */
@ -970,7 +970,7 @@ enumerate_local_dofs(size_t cf,
/* ---------------------------------------------------------------------- */
static void
unenumerate_local_dofs(size_t cf,
grid_t *g ,
struct UnstructuredGrid *g ,
struct coarse_topology *ct,
struct coarse_sys_meta *m)
/* ---------------------------------------------------------------------- */
@ -1004,7 +1004,7 @@ unenumerate_local_dofs(size_t cf,
/* ---------------------------------------------------------------------- */
static void
linearise_local_dof(size_t cf,
grid_t *g ,
struct UnstructuredGrid *g ,
struct coarse_topology *ct,
struct coarse_sys_meta *m ,
struct bf_asm_data *bf_asm)
@ -1123,7 +1123,7 @@ define_csr_sparsity(size_t nc, size_t m, struct bf_asm_data *bf_asm)
static void
assemble_local_system(size_t cf ,
size_t nlocf,
grid_t *g ,
struct UnstructuredGrid *g ,
const double *Binv ,
double *w ,
struct coarse_topology *ct ,
@ -1212,7 +1212,7 @@ Binv_scale_mobility(int nc, struct coarse_sys_meta *m,
* field. */
/* ---------------------------------------------------------------------- */
static void
symmetrise_flux(size_t cf, grid_t *g, struct coarse_topology *ct,
symmetrise_flux(size_t cf, struct UnstructuredGrid *g, struct coarse_topology *ct,
struct coarse_sys_meta *m, struct bf_asm_data *bf_asm)
/* ---------------------------------------------------------------------- */
{
@ -1303,7 +1303,7 @@ symmetrise_flux(size_t cf, grid_t *g, struct coarse_topology *ct,
/* ---------------------------------------------------------------------- */
static void
solve_local_system(size_t cf ,
grid_t *g ,
struct UnstructuredGrid *g ,
const double *Binv ,
struct coarse_topology *ct ,
struct coarse_sys_meta *m ,
@ -1420,7 +1420,7 @@ store_basis_function(size_t cf ,
* NULL if not. */
/* ---------------------------------------------------------------------- */
struct coarse_sys *
coarse_sys_construct(grid_t *g, const int *p,
coarse_sys_construct(struct UnstructuredGrid *g, const int *p,
struct coarse_topology *ct,
const double *perm,
const double *src,
@ -1798,7 +1798,7 @@ coarse_sys_compute_Binv(int nb,
/* ---------------------------------------------------------------------- */
void
coarse_sys_compute_fs_flux(grid_t *G,
coarse_sys_compute_fs_flux(struct UnstructuredGrid *G,
struct coarse_topology *ct,
struct coarse_sys *sys,
const int *b2c_pos,

4
opm/core/pressure/msmfem/coarse_sys.h
View File

@ -51,7 +51,7 @@ typedef void (*LocalSolver)(struct CSRMatrix *A,
double *x);
struct coarse_sys *
coarse_sys_construct(grid_t *g, const int *p,
coarse_sys_construct(struct UnstructuredGrid *g, const int *p,
struct coarse_topology *ct,
const double *perm,
const double *src,
@ -81,7 +81,7 @@ coarse_sys_compute_Binv(int nb,
double *work);
void
coarse_sys_compute_fs_flux(grid_t *g,
coarse_sys_compute_fs_flux(struct UnstructuredGrid *g,
struct coarse_topology *ct,
struct coarse_sys *sys,
const int *b2c_pos,

10
opm/core/pressure/msmfem/ifsh_ms.c
View File

@ -145,7 +145,7 @@ count_blkdof(struct ifsh_ms_impl *pimpl)
/* ---------------------------------------------------------------------- */
static int
ifsh_ms_vectors_construct(grid_t *G, struct ifsh_ms_impl *pimpl)
ifsh_ms_vectors_construct(struct UnstructuredGrid *G, struct ifsh_ms_impl *pimpl)
/* ---------------------------------------------------------------------- */
{
size_t nb, n_fs_gconn;
@ -186,7 +186,7 @@ ifsh_ms_vectors_construct(grid_t *G, struct ifsh_ms_impl *pimpl)
/* ---------------------------------------------------------------------- */
static void
set_impl_pointers(grid_t *G, struct ifsh_ms_data *h)
set_impl_pointers(struct UnstructuredGrid *G, struct ifsh_ms_data *h)
/* ---------------------------------------------------------------------- */
{
size_t nb, n_fs_gconn;
@ -289,7 +289,7 @@ ifsh_ms_matrix_construct(size_t m, size_t nnz, size_t nb,
/* ---------------------------------------------------------------------- */
static struct ifsh_ms_impl *
ifsh_ms_impl_construct(grid_t *G ,
ifsh_ms_impl_construct(struct UnstructuredGrid *G ,
const int *p ,
const double *perm ,
const double *src ,
@ -373,7 +373,7 @@ average_flux(size_t nf, const int *N, double *flux) /* Poor name */
/* ---------------------------------------------------------------------- */
struct ifsh_ms_data *
ifsh_ms_construct(grid_t *G ,
ifsh_ms_construct(struct UnstructuredGrid *G ,
const int *p ,
const double *perm ,
const double *src ,
@ -494,7 +494,7 @@ ifsh_ms_assemble(const double *src ,
/* ---------------------------------------------------------------------- */
void
ifsh_ms_press_flux(grid_t *G, struct ifsh_ms_data *h,
ifsh_ms_press_flux(struct UnstructuredGrid *G, struct ifsh_ms_data *h,
double *cpress, double *fflux)
/* ---------------------------------------------------------------------- */
{

4
opm/core/pressure/msmfem/ifsh_ms.h
View File

@ -44,7 +44,7 @@ struct ifsh_ms_data {
struct ifsh_ms_data *
ifsh_ms_construct(grid_t *G,
ifsh_ms_construct(struct UnstructuredGrid *G,
const int *p,
const double *perm,
const double *src,
@ -60,7 +60,7 @@ ifsh_ms_assemble(const double *src,
struct ifsh_ms_data *h);
void
ifsh_ms_press_flux(grid_t *G, struct ifsh_ms_data *h,
ifsh_ms_press_flux(struct UnstructuredGrid *G, struct ifsh_ms_data *h,
double *cpress, double *fflux);

44
opm/core/pressure/tpfa/cfs_tpfa.c
View File

@ -78,7 +78,7 @@ deallocate_densrat(struct densrat_util *ratio)
/* ---------------------------------------------------------------------- */
static struct densrat_util *
allocate_densrat(grid_t *g, well_t *w, int np)
allocate_densrat(struct UnstructuredGrid *g, well_t *w, int np)
/* ---------------------------------------------------------------------- */
{
int ntotperf;
@ -137,7 +137,7 @@ impl_deallocate(struct cfs_tpfa_impl *pimpl)
/* ---------------------------------------------------------------------- */
static struct cfs_tpfa_impl *
impl_allocate(grid_t *G, well_t *W, int np)
impl_allocate(struct UnstructuredGrid *G, well_t *W, int np)
/* ---------------------------------------------------------------------- */
{
size_t nnu, ngconn, nwperf;
@ -189,7 +189,7 @@ impl_allocate(grid_t *G, well_t *W, int np)
/* ---------------------------------------------------------------------- */
static struct CSRMatrix *
construct_matrix(grid_t *G, well_t *W)
construct_matrix(struct UnstructuredGrid *G, well_t *W)
/* ---------------------------------------------------------------------- */
{
int f, c1, c2, w, i, nc, nnu;
@ -281,7 +281,7 @@ construct_matrix(grid_t *G, well_t *W)
/* ---------------------------------------------------------------------- */
static void
solve_cellsys_core(grid_t *G ,
solve_cellsys_core(struct UnstructuredGrid *G ,
size_t sz ,
const double *Ac ,
const double *bf ,
@ -359,7 +359,7 @@ small_matvec(size_t n,
/* ---------------------------------------------------------------------- */
static void
solve_cellsys(grid_t *G ,
solve_cellsys(struct UnstructuredGrid *G ,
size_t sz,
const double *Ac,
const double *bf,
@ -373,7 +373,7 @@ solve_cellsys(grid_t *G ,
/* ---------------------------------------------------------------------- */
static void
set_dynamic_trans(grid_t *G ,
set_dynamic_trans(struct UnstructuredGrid *G ,
const double *trans,
struct compr_quantities *cq ,
struct densrat_util *ratio)
@ -391,7 +391,7 @@ set_dynamic_trans(grid_t *G ,
/* ---------------------------------------------------------------------- */
static void
set_dynamic_grav(grid_t *G ,
set_dynamic_grav(struct UnstructuredGrid *G ,
flowbc_t *bc ,
const double *trans ,
const double *gravcap_f,
@ -460,7 +460,7 @@ set_dynamic_grav_well(well_t *W,
/* ---------------------------------------------------------------------- */
static void
sum_phase_contrib(grid_t *G ,
sum_phase_contrib(struct UnstructuredGrid *G ,
size_t sz ,
const double *xcf,
double *sum)
@ -485,7 +485,7 @@ sum_phase_contrib(grid_t *G ,
/* ---------------------------------------------------------------------- */
static void
compute_densrat_update(grid_t *G ,
compute_densrat_update(struct UnstructuredGrid *G ,
struct compr_quantities *cq ,
struct densrat_util *ratio,
double *q)
@ -558,7 +558,7 @@ compute_densrat_update_well(well_t *W ,
/* ---------------------------------------------------------------------- */
static void
compute_psys_contrib(grid_t *G,
compute_psys_contrib(struct UnstructuredGrid *G,
well_t *W,
struct completion_data *wdata,
flowbc_t *bc,
@ -627,7 +627,7 @@ compute_psys_contrib(grid_t *G,
/* ---------------------------------------------------------------------- */
static int
assemble_cell_contrib(grid_t *G,
assemble_cell_contrib(struct UnstructuredGrid *G,
flowbc_t *bc,
const double *src,
struct cfs_tpfa_data *h)
@ -734,7 +734,7 @@ assemble_well_contrib(size_t nc,
/* ---------------------------------------------------------------------- */
static void
compute_fpress(grid_t *G,
compute_fpress(struct UnstructuredGrid *G,
flowbc_t *bc,
int np,
const double *htrans,
@ -790,7 +790,7 @@ compute_fpress(grid_t *G,
/* ---------------------------------------------------------------------- */
static void
compute_flux(grid_t *G,
compute_flux(struct UnstructuredGrid *G,
flowbc_t *bc,
int np,
const double *trans,
@ -896,7 +896,7 @@ is_incompr(int nc, struct compr_quantities *cq)
/* ---------------------------------------------------------------------- */
struct cfs_tpfa_data *
cfs_tpfa_construct(grid_t *G, well_t *W, int nphases)
cfs_tpfa_construct(struct UnstructuredGrid *G, well_t *W, int nphases)
/* ---------------------------------------------------------------------- */
{
size_t nc, nf, ngconn, nwconn;
@ -950,7 +950,7 @@ cfs_tpfa_construct(grid_t *G, well_t *W, int nphases)
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_assemble(grid_t *G,
cfs_tpfa_assemble(struct UnstructuredGrid *G,
double dt,
well_t *W,
flowbc_t *bc,
@ -992,7 +992,7 @@ cfs_tpfa_assemble(grid_t *G,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_press_flux(grid_t *G,
cfs_tpfa_press_flux(struct UnstructuredGrid *G,
flowbc_t *bc,
well_t *W,
int np,
@ -1027,7 +1027,7 @@ cfs_tpfa_press_flux(grid_t *G,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_fpress(grid_t *G,
cfs_tpfa_fpress(struct UnstructuredGrid *G,
flowbc_t *bc,
int np,
const double *htrans,
@ -1046,7 +1046,7 @@ cfs_tpfa_fpress(grid_t *G,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_retrieve_masstrans(grid_t *G,
cfs_tpfa_retrieve_masstrans(struct UnstructuredGrid *G,
int np,
struct cfs_tpfa_data *h,
double *masstrans_f)
@ -1059,7 +1059,7 @@ cfs_tpfa_retrieve_masstrans(grid_t *G,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_retrieve_gravtrans(grid_t *G,
cfs_tpfa_retrieve_gravtrans(struct UnstructuredGrid *G,
int np,
struct cfs_tpfa_data *h,
double *gravtrans_f)
@ -1073,7 +1073,7 @@ cfs_tpfa_retrieve_gravtrans(grid_t *G,
/* ---------------------------------------------------------------------- */
static double
cfs_tpfa_impes_maxtime_cell(int c,
grid_t *G,
struct UnstructuredGrid *G,
struct compr_quantities *cq,
const double *trans,
const double *porevol,
@ -1189,7 +1189,7 @@ cfs_tpfa_impes_maxtime_cell(int c,
/* ---------------------------------------------------------------------- */
double
cfs_tpfa_impes_maxtime(grid_t *G,
cfs_tpfa_impes_maxtime(struct UnstructuredGrid *G,
struct compr_quantities *cq,
const double *trans,
const double *porevol,
@ -1216,7 +1216,7 @@ cfs_tpfa_impes_maxtime(grid_t *G,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_expl_mass_transport(grid_t *G,
cfs_tpfa_expl_mass_transport(struct UnstructuredGrid *G,
well_t *W,
struct completion_data *wdata,
int np,

16
opm/core/pressure/tpfa/cfs_tpfa.h
View File

@ -42,10 +42,10 @@ struct cfs_tpfa_data {
struct cfs_tpfa_data *
cfs_tpfa_construct(grid_t *G, well_t *W, int nphases);
cfs_tpfa_construct(struct UnstructuredGrid *G, well_t *W, int nphases);
void
cfs_tpfa_assemble(grid_t *G,
cfs_tpfa_assemble(struct UnstructuredGrid *G,
double dt,
well_t *W,
flowbc_t *bc,
@ -60,7 +60,7 @@ cfs_tpfa_assemble(grid_t *G,
struct cfs_tpfa_data *h);
void
cfs_tpfa_press_flux(grid_t *G,
cfs_tpfa_press_flux(struct UnstructuredGrid *G,
flowbc_t *bc,
well_t *W,
int np,
@ -75,7 +75,7 @@ cfs_tpfa_press_flux(grid_t *G,
double *wflux);
void
cfs_tpfa_fpress(grid_t *G,
cfs_tpfa_fpress(struct UnstructuredGrid *G,
flowbc_t *bc,
int np,
const double *htrans,
@ -87,19 +87,19 @@ cfs_tpfa_fpress(grid_t *G,
double *fpress);
void
cfs_tpfa_retrieve_masstrans(grid_t *G,
cfs_tpfa_retrieve_masstrans(struct UnstructuredGrid *G,
int np,
struct cfs_tpfa_data *h,
double *masstrans_f);
void
cfs_tpfa_retrieve_gravtrans(grid_t *G,
cfs_tpfa_retrieve_gravtrans(struct UnstructuredGrid *G,
int np,
struct cfs_tpfa_data *h,
double *gravtrans_f);
double
cfs_tpfa_impes_maxtime(grid_t *G,
cfs_tpfa_impes_maxtime(struct UnstructuredGrid *G,
struct compr_quantities *cq,
const double *trans,
const double *porevol,
@ -109,7 +109,7 @@ cfs_tpfa_impes_maxtime(grid_t *G,
const double *gravity);
void
cfs_tpfa_expl_mass_transport(grid_t *G,
cfs_tpfa_expl_mass_transport(struct UnstructuredGrid *G,
well_t *W,
struct completion_data *wdata,
int np,

38
opm/core/pressure/tpfa/cfs_tpfa_residual.c
View File

@ -128,7 +128,7 @@ impl_deallocate(struct cfs_tpfa_res_impl *pimpl)
/* ---------------------------------------------------------------------- */
static struct cfs_tpfa_res_impl *
impl_allocate(grid_t *G ,
impl_allocate(struct UnstructuredGrid *G ,
struct WellCompletions *wconn ,
size_t max_conn,
int np )
@ -181,7 +181,7 @@ impl_allocate(grid_t *G ,
/* ---------------------------------------------------------------------- */
static struct CSRMatrix *
construct_matrix(grid_t *G, struct WellCompletions *wconn)
construct_matrix(struct UnstructuredGrid *G, struct WellCompletions *wconn)
/* ---------------------------------------------------------------------- */
{
int f, c1, c2, w, i, nc, nnu;
@ -362,7 +362,7 @@ compute_darcyflux_and_deriv(int np,
static void
compute_compflux_and_deriv(grid_t *G ,
compute_compflux_and_deriv(struct UnstructuredGrid *G ,
int np ,
const double *cpress,
const double *trans ,
@ -459,7 +459,7 @@ compute_well_compflux_and_deriv(struct cfs_tpfa_res_wells *W ,
static int
count_internal_conn(grid_t *G, int c)
count_internal_conn(struct UnstructuredGrid *G, int c)
{
int c1, c2, f, i, nconn;
@ -478,7 +478,7 @@ count_internal_conn(grid_t *G, int c)
static int
init_cell_contrib(grid_t *G ,
init_cell_contrib(struct UnstructuredGrid *G ,
int c ,
int np ,
double pvol ,
@ -526,7 +526,7 @@ init_cell_contrib(grid_t *G ,
static void
compute_cell_contrib(grid_t *G ,
compute_cell_contrib(struct UnstructuredGrid *G ,
int c ,
int np ,
double pvol ,
@ -621,7 +621,7 @@ assemble_sources(double dt ,
/* ---------------------------------------------------------------------- */
static int
assemble_cell_contrib(grid_t *G,
assemble_cell_contrib(struct UnstructuredGrid *G,
int c,
struct cfs_tpfa_res_data *h)
/* ---------------------------------------------------------------------- */
@ -878,7 +878,7 @@ assemble_well_contrib(struct cfs_tpfa_res_wells *W ,
/* ---------------------------------------------------------------------- */
static void
compute_fpress(grid_t *G,
compute_fpress(struct UnstructuredGrid *G,
int np,
const double *htrans,
const double *pmobf,
@ -935,7 +935,7 @@ compute_fpress(grid_t *G,
/* ---------------------------------------------------------------------- */
static void
compute_flux(grid_t *G,
compute_flux(struct UnstructuredGrid *G,
int np,
const double *trans,
const double *pmobf,
@ -1020,7 +1020,7 @@ compute_wflux(int np ,
static size_t
maxconn(grid_t *G)
maxconn(struct UnstructuredGrid *G)
{
int c;
size_t m, n;
@ -1056,7 +1056,7 @@ cfs_tpfa_res_destroy(struct cfs_tpfa_res_data *h)
/* ---------------------------------------------------------------------- */
struct cfs_tpfa_res_data *
cfs_tpfa_res_construct(grid_t *G ,
cfs_tpfa_res_construct(struct UnstructuredGrid *G ,
struct WellCompletions *wconn ,
int nphases)
/* ---------------------------------------------------------------------- */
@ -1111,7 +1111,7 @@ cfs_tpfa_res_construct(grid_t *G ,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_res_assemble(grid_t *G,
cfs_tpfa_res_assemble(struct UnstructuredGrid *G,
double dt,
struct cfs_tpfa_res_forces *forces,
const double *zc,
@ -1169,7 +1169,7 @@ cfs_tpfa_res_assemble(grid_t *G,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_res_flux(grid_t *G ,
cfs_tpfa_res_flux(struct UnstructuredGrid *G ,
struct cfs_tpfa_res_forces *forces ,
int np ,
const double *trans ,
@ -1194,7 +1194,7 @@ cfs_tpfa_res_flux(grid_t *G ,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_res_fpress(grid_t *G,
cfs_tpfa_res_fpress(struct UnstructuredGrid *G,
int np,
const double *htrans,
const double *pmobf,
@ -1213,7 +1213,7 @@ cfs_tpfa_res_fpress(grid_t *G,
#if 0
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_res_retrieve_masstrans(grid_t *G,
cfs_tpfa_res_retrieve_masstrans(struct UnstructuredGrid *G,
int np,
struct cfs_tpfa_res_data *h,
double *masstrans_f)
@ -1226,7 +1226,7 @@ cfs_tpfa_res_retrieve_masstrans(grid_t *G,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_res_retrieve_gravtrans(grid_t *G,
cfs_tpfa_res_retrieve_gravtrans(struct UnstructuredGrid *G,
int np,
struct cfs_tpfa_res_data *h,
double *gravtrans_f)
@ -1240,7 +1240,7 @@ cfs_tpfa_res_retrieve_gravtrans(grid_t *G,
/* ---------------------------------------------------------------------- */
static double
cfs_tpfa_res_impes_maxtime_cell(int c,
grid_t *G,
struct UnstructuredGrid *G,
struct compr_quantities *cq,
const double *trans,
const double *porevol,
@ -1356,7 +1356,7 @@ cfs_tpfa_res_impes_maxtime_cell(int c,
/* ---------------------------------------------------------------------- */
double
cfs_tpfa_res_impes_maxtime(grid_t *G,
cfs_tpfa_res_impes_maxtime(struct UnstructuredGrid *G,
struct compr_quantities *cq,
const double *trans,
const double *porevol,
@ -1383,7 +1383,7 @@ cfs_tpfa_res_impes_maxtime(grid_t *G,
/* ---------------------------------------------------------------------- */
void
cfs_tpfa_res_expl_mass_transport(grid_t *G,
cfs_tpfa_res_expl_mass_transport(struct UnstructuredGrid *G,
well_t *W,
struct completion_data *wdata,
int np,

16
opm/core/pressure/tpfa/cfs_tpfa_residual.h
View File

@ -54,7 +54,7 @@ struct cfs_tpfa_res_data {
struct cfs_tpfa_res_data *
cfs_tpfa_res_construct(grid_t *G ,
cfs_tpfa_res_construct(struct UnstructuredGrid *G ,
struct WellCompletions *wconn ,
int nphases);
@ -62,7 +62,7 @@ void
cfs_tpfa_res_destroy(struct cfs_tpfa_res_data *h);
void
cfs_tpfa_res_assemble(grid_t *G,
cfs_tpfa_res_assemble(struct UnstructuredGrid *G,
double dt,
struct cfs_tpfa_res_forces *forces,
const double *zc,
@ -75,7 +75,7 @@ cfs_tpfa_res_assemble(grid_t *G,
struct cfs_tpfa_res_data *h);
void
cfs_tpfa_res_flux(grid_t *G ,
cfs_tpfa_res_flux(struct UnstructuredGrid *G ,
struct cfs_tpfa_res_forces *forces ,
int np ,
const double *trans ,
@ -88,7 +88,7 @@ cfs_tpfa_res_flux(grid_t *G ,
double *wflux );
void
cfs_tpfa_res_fpress(grid_t *G,
cfs_tpfa_res_fpress(struct UnstructuredGrid *G,
int np,
const double *htrans,
const double *pmobf,
@ -100,19 +100,19 @@ cfs_tpfa_res_fpress(grid_t *G,
#if 0
void
cfs_tpfa_retrieve_masstrans(grid_t *G,
cfs_tpfa_retrieve_masstrans(struct UnstructuredGrid *G,
int np,
struct cfs_tpfa_data *h,
double *masstrans_f);
void
cfs_tpfa_retrieve_gravtrans(grid_t *G,
cfs_tpfa_retrieve_gravtrans(struct UnstructuredGrid *G,
int np,
struct cfs_tpfa_data *h,
double *gravtrans_f);
double
cfs_tpfa_impes_maxtime(grid_t *G,
cfs_tpfa_impes_maxtime(struct UnstructuredGrid *G,
struct compr_quantities *cq,
const double *trans,
const double *porevol,
@ -122,7 +122,7 @@ cfs_tpfa_impes_maxtime(grid_t *G,
const double *gravity);
void
cfs_tpfa_expl_mass_transport(grid_t *G,
cfs_tpfa_expl_mass_transport(struct UnstructuredGrid *G,
well_t *W,
struct completion_data *wdata,
int np,

2
opm/core/pressure/tpfa/compr_quant.c
View File

@ -24,7 +24,7 @@
/* Compute B \ (V') == zeta(cellNo) .* faceFlux2CellFlux(fflux) */
/* ---------------------------------------------------------------------- */
void
compr_flux_term(grid_t *G,
compr_flux_term(struct UnstructuredGrid *G,
const double *fflux,
const double *zeta,
double *Biv)

2
opm/core/pressure/tpfa/compr_quant.h
View File

@ -39,7 +39,7 @@ struct compr_quantities {
};
void
compr_flux_term(grid_t *G,
compr_flux_term(struct UnstructuredGrid *G,
const double *fflux,
const double *zeta,
double *Biv);

12
opm/core/pressure/tpfa/ifs_tpfa.c
View File

@ -30,7 +30,7 @@ impl_deallocate(struct ifs_tpfa_impl *pimpl)
/* ---------------------------------------------------------------------- */
static struct ifs_tpfa_impl *
impl_allocate(grid_t *G)
impl_allocate(struct UnstructuredGrid *G)
/* ---------------------------------------------------------------------- */
{
struct ifs_tpfa_impl *new;
@ -57,7 +57,7 @@ impl_allocate(grid_t *G)
/* ---------------------------------------------------------------------- */
static struct CSRMatrix *
ifs_tpfa_construct_matrix(grid_t *G)
ifs_tpfa_construct_matrix(struct UnstructuredGrid *G)
/* ---------------------------------------------------------------------- */
{
int f, c1, c2;
@ -122,7 +122,7 @@ ifs_tpfa_construct_matrix(grid_t *G)
/* fgrav = accumarray(cf(j), grav(j).*sgn(j), [nf, 1]) */
/* ---------------------------------------------------------------------- */
static void
compute_grav_term(grid_t *G, const double *gpress,
compute_grav_term(struct UnstructuredGrid *G, const double *gpress,
double *fgrav)
/* ---------------------------------------------------------------------- */
{
@ -155,7 +155,7 @@ compute_grav_term(grid_t *G, const double *gpress,
/* ---------------------------------------------------------------------- */
struct ifs_tpfa_data *
ifs_tpfa_construct(grid_t *G)
ifs_tpfa_construct(struct UnstructuredGrid *G)
/* ---------------------------------------------------------------------- */
{
struct ifs_tpfa_data *new;
@ -185,7 +185,7 @@ ifs_tpfa_construct(grid_t *G)
/* ---------------------------------------------------------------------- */
void
ifs_tpfa_assemble(grid_t *G,
ifs_tpfa_assemble(struct UnstructuredGrid *G,
const double *trans,
const double *src,
const double *gpress,
@ -232,7 +232,7 @@ ifs_tpfa_assemble(grid_t *G,
/* ---------------------------------------------------------------------- */
void
ifs_tpfa_press_flux(grid_t *G,
ifs_tpfa_press_flux(struct UnstructuredGrid *G,
const double *trans,
struct ifs_tpfa_data *h,
double *cpress,

6
opm/core/pressure/tpfa/ifs_tpfa.h
View File

@ -39,17 +39,17 @@ struct ifs_tpfa_data {
struct ifs_tpfa_data *
ifs_tpfa_construct(grid_t *G);
ifs_tpfa_construct(struct UnstructuredGrid *G);
void
ifs_tpfa_assemble(grid_t *G,
ifs_tpfa_assemble(struct UnstructuredGrid *G,
const double *trans,
const double *src,
const double *gpress,
struct ifs_tpfa_data *h);
void
ifs_tpfa_press_flux(grid_t *G,
ifs_tpfa_press_flux(struct UnstructuredGrid *G,
const double *trans,
struct ifs_tpfa_data *h,
double *cpress,

6
opm/core/pressure/tpfa/trans_tpfa.c
View File

@ -10,7 +10,7 @@
/* htrans <- sum(C(:,i) .* K(cellNo,:) .* N(:,j), 2) ./ sum(C.*C, 2) */
/* ---------------------------------------------------------------------- */
void
tpfa_htrans_compute(grid_t *G, const double *perm, double *htrans)
tpfa_htrans_compute(struct UnstructuredGrid *G, const double *perm, double *htrans)
/* ---------------------------------------------------------------------- */
{
int c, d, f, i, j;
@ -61,7 +61,7 @@ tpfa_htrans_compute(grid_t *G, const double *perm, double *htrans)
/* ---------------------------------------------------------------------- */
void
tpfa_trans_compute(grid_t *G, const double *htrans, double *trans)
tpfa_trans_compute(struct UnstructuredGrid *G, const double *htrans, double *trans)
/* ---------------------------------------------------------------------- */
{
int c, i, f;
@ -86,7 +86,7 @@ tpfa_trans_compute(grid_t *G, const double *htrans, double *trans)
/* ---------------------------------------------------------------------- */
void
tpfa_eff_trans_compute(grid_t *G,
tpfa_eff_trans_compute(struct UnstructuredGrid *G,
const double *totmob,
const double *htrans,
double *trans)

6
opm/core/pressure/tpfa/trans_tpfa.h
View File

@ -27,13 +27,13 @@ extern "C" {
#endif
void
tpfa_htrans_compute(grid_t *G, const double *perm, double *htrans);
tpfa_htrans_compute(struct UnstructuredGrid *G, const double *perm, double *htrans);
void
tpfa_trans_compute(grid_t *G, const double *htrans, double *trans);
tpfa_trans_compute(struct UnstructuredGrid *G, const double *htrans, double *trans);
void
tpfa_eff_trans_compute(grid_t *G,
tpfa_eff_trans_compute(struct UnstructuredGrid *G,
const double *totmob,
const double *htrans,
double *trans);

2
opm/core/transport/spu_explicit.c
View File

@ -13,7 +13,7 @@
/* Twophase mobility-weighted upwind */
void
spu_explicit(grid_t *g, double *s0, double *s, double *mob,
spu_explicit(struct UnstructuredGrid *g, double *s0, double *s, double *mob,
double *dflux, double *gflux, double *src,
double dt)
{

2
opm/core/transport/spu_explicit.h
View File

@ -6,7 +6,7 @@
#ifndef SPU_EXPLICIT_H_INCLUDED
#define SPU_EXPLICIT_H_INCLUDED
void
spu_explicit(grid_t *g,
spu_explicit(struct UnstructuredGrid *g,
double *s0,
double *s,
double *mob,

4
opm/core/transport/spu_implicit.c
View File

@ -132,7 +132,7 @@ compute_mobilities(int n, double *s, double *mob, double *dmob, int ntab, double
*
*/
double
spu_implicit(grid_t *g, double *s0, double *s, double h, double x0, int ntab, double *tab,
spu_implicit(struct UnstructuredGrid *g, double *s0, double *s, double h, double x0, int ntab, double *tab,
double *dflux, double *gflux, double *src, double dt,
void (*linear_solver)(int, int*, int*, double *, double *, double *))
{
@ -277,7 +277,7 @@ phase_upwind_mobility(double darcyflux, double gravityflux, int i, int c,
}
void
spu_implicit_assemble(grid_t *g, double *s0, double *s, double *mob, double *dmob,
spu_implicit_assemble(struct UnstructuredGrid *g, double *s0, double *s, double *mob, double *dmob,
double *dflux, double *gflux, double *src, double dt, sparse_t *S,
double *b, char *work)
{

4
opm/core/transport/spu_implicit.h
View File

@ -17,12 +17,12 @@ typedef struct Sparse {
void
spu_implicit_assemble(grid_t *g, double *s0, double *s, double *mob, double *dmob,
spu_implicit_assemble(struct UnstructuredGrid *g, double *s0, double *s, double *mob, double *dmob,
double *dflux, double *gflux, double *src, double dt, sparse_t *S,
double *b, char *work);
double
spu_implicit(grid_t *g, double *s0, double *s, double h, double x0, int ntab, double *tab,
spu_implicit(struct UnstructuredGrid *g, double *s0, double *s, double h, double x0, int ntab, double *tab,
double *dflux, double *gflux, double *src, double dt,
void (*linear_solver)(int, int*, int*, double *, double *, double *));

210
opm/core/utility/cpgpreprocess/cgridinterface.c
View File

@ -14,21 +14,18 @@
#include <assert.h>
#include <stdlib.h>
#include "geometry.h"
#include "cgridinterface.h"
#include <opm/core/utility/cpgpreprocess/geometry.h>
#include <opm/core/utility/cpgpreprocess/preprocess.h>
#include <opm/core/grid.h>
static int
fill_cell_topology(struct processed_grid *pg,
struct CornerpointGrid *G )
struct UnstructuredGrid *g )
{
int f, c1, c2, tag;
size_t c, nc, nhf;
struct UnstructuredGrid *g;
g = (struct UnstructuredGrid *) G;
nc = g->number_of_cells;
g->cell_facepos = malloc((nc + 1) * sizeof *g->cell_facepos);
@ -54,11 +51,11 @@ fill_cell_topology(struct processed_grid *pg,
g->cell_faces = malloc(nhf * sizeof *g->cell_faces);
/* struct CornerpointGrid member */
G->cface_tag = malloc(nhf * sizeof *G->cface_tag );
if ((g->cell_faces == NULL) || (G->cface_tag == NULL)) {
free(G->cface_tag); G->cface_tag = NULL;
/* struct UnstructuredGrid member */
g->cell_facetag = malloc(nhf * sizeof *g->cell_facetag );
if ((g->cell_faces == NULL) || (g->cell_facetag == NULL)) {
free(g->cell_facetag); g->cell_facetag = NULL;
free(g->cell_faces); g->cell_faces = NULL;
free(g->cell_facepos); g->cell_facepos = NULL;
}
@ -71,19 +68,15 @@ fill_cell_topology(struct processed_grid *pg,
c2 = g->face_cells[2*f + 1];
if (c1 >= 0) {
g->cell_faces[ g->cell_facepos[c1 + 1] ] = f;
/* struct CornerpointGrid member (!) */
G->cface_tag [ g->cell_facepos[c1 + 1] ] = tag + 1;
g->cell_faces [ g->cell_facepos[c1 + 1] ] = f;
g->cell_facetag [ g->cell_facepos[c1 + 1] ] = tag + 1;
g->cell_facepos[c1 + 1] += 1;
}
if (c2 >= 0) {
g->cell_faces[ g->cell_facepos[c2 + 1] ] = f;
/* struct CornerpointGrid member (!) */
G->cface_tag [ g->cell_facepos[c2 + 1] ] = tag + 0;
g->cell_faces [ g->cell_facepos[c2 + 1] ] = f;
g->cell_facetag [ g->cell_facepos[c2 + 1] ] = tag + 0;
g->cell_facepos[c2 + 1] += 1;
}
@ -93,6 +86,30 @@ fill_cell_topology(struct processed_grid *pg,
return g->cell_facepos != NULL;
}
void free_cornerpoint_grid(struct UnstructuredGrid *g)
{
if (g!=NULL)
{
free(g->face_nodes);
free(g->face_nodepos);
free(g->face_cells);
free(g->cell_facepos);
free(g->cell_faces);
free(g->node_coordinates);
free(g->face_centroids);
free(g->face_areas);
free(g->face_normals);
free(g->cell_centroids);
free(g->cell_volumes);
free(g->global_cell);
free(g->cell_facetag);
}
free(g);
}
static int
allocate_geometry(struct UnstructuredGrid *g)
{
@ -122,100 +139,93 @@ allocate_geometry(struct UnstructuredGrid *g)
return ok == 5;
}
void preprocess (const struct grdecl *in,
double tol,
struct CornerpointGrid *G)
void compute_geometry(struct UnstructuredGrid *g)
{
assert (g != NULL);
if (g!=NULL)
{
assert (g->dimensions == 3);
assert (g->face_centroids != NULL);
assert (g->face_normals != NULL);
assert (g->face_areas != NULL);
assert (g->cell_centroids != NULL);
assert (g->cell_volumes != NULL);
compute_face_geometry(g->dimensions , g->node_coordinates,
g->number_of_faces, g->face_nodepos,
g->face_nodes, g->face_normals,
g->face_centroids, g->face_areas);
compute_cell_geometry(g->dimensions, g->node_coordinates,
g->face_nodepos, g->face_nodes,
g->face_cells, g->face_normals,
g->face_centroids, g->number_of_cells,
g->cell_facepos, g->cell_faces,
g->cell_centroids, g->cell_volumes);
}
}
struct UnstructuredGrid *
preprocess (const struct grdecl *in, double tol)
{
struct UnstructuredGrid *g;
int ok;
struct processed_grid pg;
struct UnstructuredGrid *base;
base = (struct UnstructuredGrid *) G;
g = malloc(1 * sizeof *g);
if (g == NULL)
{
return NULL;
}
process_grdecl(in, tol, &pg);
/*
* General grid interface
* Convert "struct processed_grid" to "struct UnstructuredGrid".
*/
base->dimensions = 3;
g->dimensions = 3;
base->number_of_nodes = pg.number_of_nodes;
base->number_of_faces = pg.number_of_faces;
base->number_of_cells = pg.number_of_cells;
g->number_of_nodes = pg.number_of_nodes;
g->number_of_faces = pg.number_of_faces;
g->number_of_cells = pg.number_of_cells;
base->node_coordinates = pg.node_coordinates;
g->node_coordinates = pg.node_coordinates;
base->face_nodes = pg.face_nodes;
base->face_nodepos = pg.face_ptr;
base->face_cells = pg.face_neighbors;
g->face_nodes = pg.face_nodes;
g->face_nodepos = pg.face_ptr;
g->face_cells = pg.face_neighbors;
base->face_centroids = NULL;
base->face_normals = NULL;
base->face_areas = NULL;
g->face_centroids = NULL;
g->face_normals = NULL;
g->face_areas = NULL;
fill_cell_topology(&pg, G);
g->cell_centroids = NULL;
g->cell_volumes = NULL;
base->cell_centroids = NULL;
base->cell_volumes = NULL;
/* allocate and fill g->cell_faces/g->cell_facepos and
* g->cell_facetag */
fill_cell_topology(&pg, g);
ok = allocate_geometry(base);
ok = allocate_geometry(g);
if (!ok)
{
free_cornerpoint_grid(g);
g = NULL;
}
else
{
compute_geometry(g);
g->cartdims[0] = pg.dimensions[0];
g->cartdims[1] = pg.dimensions[1];
g->cartdims[2] = pg.dimensions[2];
g->global_cell = pg.local_cell_index;
}
/*
* Cornerpoint grid interface
*/
G->cartdims[0] = pg.dimensions[0];
G->cartdims[1] = pg.dimensions[1];
G->cartdims[2] = pg.dimensions[2];
free(pg.face_tag);
G->index_map = pg.local_cell_index;
}
void free_cornerpoint_grid(struct CornerpointGrid *G)
{
free(G->grid.face_nodes);
free(G->grid.face_nodepos);
free(G->grid.face_cells);
free(G->grid.cell_facepos);
free(G->grid.cell_faces);
free(G->grid.node_coordinates);
free(G->grid.face_centroids);
free(G->grid.face_areas);
free(G->grid.face_normals);
free(G->grid.cell_centroids);
free(G->grid.cell_volumes);
free(G->index_map);
free(G->cface_tag);
}
void compute_geometry(struct CornerpointGrid *G)
{
struct UnstructuredGrid *g;
assert (G != NULL);
g = (struct UnstructuredGrid *) G;
assert (g->dimensions == 3);
assert (g->face_centroids != NULL);
assert (g->face_normals != NULL);
assert (g->face_areas != NULL);
assert (g->cell_centroids != NULL);
assert (g->cell_volumes != NULL);
compute_face_geometry(g->dimensions , g->node_coordinates,
g->number_of_faces, g->face_nodepos,
g->face_nodes, g->face_normals,
g->face_centroids, g->face_areas);
compute_cell_geometry(g->dimensions, g->node_coordinates,
g->face_nodepos, g->face_nodes,
g->face_cells, g->face_normals,
g->face_centroids, g->number_of_cells,
g->cell_facepos, g->cell_faces,
g->cell_centroids, g->cell_volumes);
return g;
}

23
opm/core/utility/cpgpreprocess/cgridinterface.h
View File

@ -26,25 +26,12 @@
extern "C" {
#endif
struct CornerpointGrid {
struct UnstructuredGrid grid;
struct UnstructuredGrid *
preprocess (const struct grdecl *in, double tol);
/*
* Special cornerpoint definitions
*/
int cartdims[3];
int *index_map;
int *cface_tag;
};
void preprocess (const struct grdecl *in,
double tol,
struct CornerpointGrid *out);
void compute_geometry (struct CornerpointGrid *g);
void free_cornerpoint_grid(struct CornerpointGrid *g);
void compute_geometry (struct UnstructuredGrid *g);
void free_cornerpoint_grid(struct UnstructuredGrid *g);
#ifdef __cplusplus
}
#endif

4
opm/core/utility/cpgpreprocess/preprocess.c
View File

@ -13,8 +13,8 @@
//==========================================================================*/
/*
Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
Copyright 2009, 2010 Statoil ASA.
Copyright 2009, 2010, 2011, 2012 SINTEF ICT, Applied Mathematics.
Copyright 2009, 2010, 2011, 2012 Statoil ASA.
This file is part of The Open Reservoir Simulator Project (OpenRS).

10
tests/test_cfs_tpfa.c
View File

@ -155,7 +155,7 @@ call_UMFPACK(struct CSRMatrix *A, double *b, double *x)
}
static void
deallocate_cart_grid(grid_t *G)
deallocate_cart_grid(struct UnstructuredGrid *G)
{
if (G != NULL) {
free(G->node_coordinates);
@ -176,7 +176,7 @@ deallocate_cart_grid(grid_t *G)
free(G);
}
static grid_t *
static struct UnstructuredGrid *
cart_grid(int nx, int ny, int nz)
{
/* The following applies to any grid derived from base_grid_t. */
@ -196,7 +196,7 @@ cart_grid(int nx, int ny, int nz)
int nyf = nx*Ny*nz;
int nzf = nx*ny*Nz;
grid_t *G = malloc(1 * sizeof *G);
struct UnstructuredGrid *G = malloc(1 * sizeof *G);
G->dimensions = 3;
@ -489,7 +489,7 @@ destroy_wells(well_t *W)
static well_t *
create_wells(grid_t *G)
create_wells(struct UnstructuredGrid *G)
{
well_t *new = malloc(1 * sizeof *new);
@ -621,7 +621,7 @@ main(void)
double *gravcap_f, *porevol, *cpress0;
double *cpress, *fpress, *fflux, *wpress, *wflux;
grid_t *G;
struct UnstructuredGrid *G;
well_t *W;
well_control_t *wctrl;
struct completion_data *wdata;

20
tests/test_readvector.cpp
View File

@ -8,7 +8,7 @@
#include <opm/core/utility/cpgpreprocess/readvector.hpp>
static struct CornerpointGrid
static struct UnstructuredGrid*
read_grid(const std::string& dir)
{
std::string fn;
@ -38,13 +38,7 @@ read_grid(const std::string& dir)
grdecl.dims[1] = dimens[1];
grdecl.dims[2] = dimens[2];
struct CornerpointGrid G;
preprocess(&grdecl, 0.0, &G);
compute_geometry(&G);
struct UnstructuredGrid *g = &G.grid;
struct UnstructuredGrid *g= preprocess(&grdecl, 0.0);
double vol = 0.0;
for (int c = 0; c < g->number_of_cells; c++) {
@ -54,20 +48,20 @@ read_grid(const std::string& dir)
for (int c = 0, i = 0; c < g->number_of_cells; c++) {
for (; i < g->cell_facepos[c + 1]; i++) {
std::cout << "(c,i) = (" << c << "," << G.cface_tag[i] << ")\n";
std::cout << "(c,i) = (" << c << "," << g->cell_facetag[i] << ")\n";
}
}
return G;
return g;
}
int main()
{
struct CornerpointGrid G;
struct UnstructuredGrid *g;
G = read_grid(std::string("example"));
g = read_grid(std::string("example"));
free_cornerpoint_grid(&G);
free_cornerpoint_grid(g);
return 0;
}