Optimization-based Upscaling for Two-Phase Flow Through Porous Media: Structured Grid Generation

Abstract

The process of coarsening the detailed geological model of a reservoir to simulation models is known as upscaling. There are two fundamental steps in the procedure of upscaling, i.e., defining the coarse grid geometry and calculating the average properties for the generated coarse grid. In this paper, the focus will be on investigating the applicability of optimization in the context of coarse grid geometry definition. To do so, different objective function candidates will be defined, and their behavior in terms of predicting the two-phase flow accuracy of coarse grids will be analyzed to determine the proper objective function. A modified objective function employing the idea of analytical dual-mesh method will be defined to reduce the optimization process time. This objective function will be employed to generate the optimum Cartesian structured coarse grid geometry using global optimization techniques. The performance of the proposed grid generation technique will be investigated through various highly heterogeneous test cases under different boundary conditions, mobility ratios, upscaling levels, and permeability upscaling methods.

Appendices

Appendix 1: Modified Objective Function Algorithm

• 1. Get the coarse grid geometry, i.e., $\mathbf {x}=(dxc_1,\cdots ,dxc_{N_{xc}}, \, dyc_1,\cdots ,dyc_{N_{yc}})$.

• 2. Calculate the coarse-scale permeability field.

• 3. Solve the single-phase flow equation on the coarse scale to obtain the flux across each coarse grid block face.

• 4. Using the obtained coarse-scale fluxes, reconstruct the velocity field over the refined grid employing Eqs. (34)-(35).

• 5. Use Eq. (16) to calculate $E\_\, SSIM \left( Vel \right)$, comparing the analytically reconstructed velocity field to the fine-scale velocity field.

Appendix 2: Mapping a Given Point to x-direction Equality Constraint Algorithm

• 1. Set $dxc_i^{old}=dxc_i, i=1,\cdots N_{xc}$.

• 2. Calculate constraint violation, i.e., $g_x=\left| \sum _{i=1}^{N_{xc}}dxc_i^{old}-N_x\times dx\right|$.

• 3. If $g_x < tol$ for a small value of $tol$, e.g., $10^{-6}$, then the mapping is completed. Set $dxc_i=dxc_i^{old}$ and exit the algorithm.

• 4. Calculate new values $dxc_i^{new}=dxc_i^{old}-\frac{1}{N_{xc}}\times g_x$.

• 5. For each $dxc_i^{new}$ that violates its corresponding bound constraints, set $dxc_i^{new} = dxc_i^{old}$.

• 6. Set $dxc_i^{old} = dxc_i^{new}$ and go to step 2.

Appendix 3: Multistart Generating Set Search Optimization Algorithm

• 1. Generate $N_{init}$ number of initial points, distributed in the domain defined by lower and upper bounds of the design parameters using Latin hypercube sampling technique.

• 2. Map each initial point to the equality constraints as stated in Appendix 2.

• 3. Calculate the objective function at the mapped points and select the $N_{init,top}$ points with the lowest function values as the initial points for the multistart method, i.e., $\mathbf {x}_{i}, i=1, \cdots , N_{init,top}$.

• 4. Normalize each initial point to $[-\mathbf 1 ,\mathbf 1 ]$ interval using the lower and upper bounds of each variable to obtain $\hat{\mathbf {x}}_i$.

• 5. Set the initial step length $\varDelta (1)=1$. Set the tolerance step length, $\varDelta _{tol}$. Set the maximum number of function evaluation, $N_{f,eval}^{max}$.

• 6. Set the expansion and contraction factors, i.e., $\rho _{exp}$ and $\rho _{cnt}$.

• 7. Set $i=1$ and perform the following steps on the $\textit{i}^{\mathrm{th}}$ normalized initial point, $\hat{\mathbf {x}}_i$.

  • 7.1. Set $\hat{\mathbf {x}}_{min}^{(i)} = \hat{\mathbf {x}}_i$.

  • 7.2. Set the iteration counter $k_{gss}=1$.

  • 7.3. Set the number of function evaluation $N_{f,eval}=0$.

  • 7.4. Given $\hat{\mathbf {x}}_{min}^{(i)}$ and $\varDelta (k_{gss})$, detect the active constraints (the constraints that might be violated in the spherical region defined by $\hat{\mathbf {x}}_{min}^{(i)}$ as the center and $\varDelta (k_{gss})$ as radius).

  • 7.5. Employ the double description method (Motzkin et al. 1953) to generate the normalized base vectors, i.e., $\mathbf {d}_j$, of the region defined by active constraints. Using these vectors as search directions ensures the trial points to be in the problem domain.

  • 7.6. If no base vectors found, reduce step length $\varDelta (k_{gss}+1)=\rho _{cnt} \, \varDelta (k_{gss})$. Set $k_{gss} = k_{gss}+1$ and go to step 7.4.

  • 7.7. For each base vector $\mathbf {d}_j$, calculate $\hat{f}(\hat{\mathbf {x}}_{min}^{(i)}+\varDelta (k_{gss}) \, \mathbf {d}_j)$ and update the number of function evaluations, $N_{f,eval}$. Determine the base vector that yields the minimum objective function value, i.e., $\mathbf {d}_{min}$.

  • 7.8. If $\hat{f}(\hat{\mathbf {x}}_{min}^{(i)}+\varDelta (k_{gss}) \, \mathbf {d}_{min}) < \hat{f}(\hat{\mathbf {x}}_{min}^{(i)}) - R(\varDelta (k_{gss}))$, then iteration is successful. Set $\hat{\mathbf {x}}_{min}^{(i)} = \hat{\mathbf {x}}_{min}^{(i)} + \varDelta (k_{gss}) \, \mathbf {d}_{min}$. If $N_{f,eval}>N_{f,eval}^{max}$, then the maximum number of function evaluations is reached. Set $i=i+1$ and go to step 7 to perform the minimization algorithm for the next normalized initial point. Otherwise, increase the step size $\varDelta (k_{gss}+1)=\rho _{exp} \, \varDelta (k_{gss})$, set $k_{gss} = k_{gss}+1$ and go to step 7.4.

  • 7.9. Decrease the step length $\varDelta (k_{gss}+1)=\rho _{cnt} \, \varDelta (k_{gss})$. If $\varDelta (k_{gss}+1)<\varDelta _{tol}$, then the algorithm reached the minimum point. Set $i=i+1$ and go to step 7 to perform the minimization algorithm for next initial point. Otherwise, increase the iteration counter $k_{gss} = k_{gss}+1$ and go to step 7.4.

• 8. Set the global normalized minimum point as $\hat{\mathbf {x}}_{min}^{global}=\hat{\mathbf {x}}_{min}^{(i)}: \hat{f}(\hat{\mathbf {x}}_{min}^{(i)})<\hat{f}(\hat{\mathbf {x}}_{min}^{(j)}),$ $i,j=1, \cdots , N_{init,top}, \; i\ne j$.

• 9. Inverse the normalization process on $\hat{\mathbf {x}}_{min}^{global}$ to obtain the optimum grid geometry $\mathbf {x}^{opt}$.

The algorithm parameters were set as $N_{init}=2500 \times (N_{xc}+N_{yc})$, $N_{init,top}=(N_{xc}+N_{yc}) / 2 - 1$, $N_{f,eval}^{max}=500 \times (N_{xc}+N_{yc})$, $\varDelta _{tol}=10^{-5}$, $\rho _{exp}=1$ and $\rho _{cnt}=0.8$. The condition stated in step 7.8 is employed to impose a sufficient decrease condition in which

$$\begin{aligned} R(\varDelta (k_{gss}))= \alpha _{gss} \, \max (\hat{f}_{typ},\, \hat{f}(\hat{\mathbf {x}}_{min}^{(i)}))\, \varDelta ^2(k_{gss}) \end{aligned}$$

(42)

where $\hat{f}_{typ}$ is a typical value of the objective function, e.g., $\hat{f}_{typ}=0.5$, and $\alpha _{gss}$ is a small number, e.g., $\alpha _{gss}=10^{-3}$. The function $\hat{f}(\hat{\mathbf {x}})$ is a simple modification of $f(\mathbf {x})$ that takes the normalized vector, $\hat{\mathbf {x}}$, as its argument.

Appendix 4: Analytical Dual-Mesh Method Algorithm

• 1. For each time step, perform the following steps until the maximum simulation time is reached.

  • 1.1. Calculate wetting-phase and non-wetting-phase relative permeabilities over the coarse scale using the saturation field of the previous time step.

  • 1.2. Solve Eq. (36) to obtain the pressure field over the coarse grid.

  • 1.3. Calculate the fluxes across coarse-scale block faces.

  • 1.4. Reconstruct the pressure and velocity fields over the fine scale.

  • 1.5. Calculate the wetting-phase and non-wetting-phase relative permeabilities over the fine scale using the saturation field of the previous time step.

  • 1.6. Solve Eq. (37) to obtain the fine-scale saturation field at the current time step.

  • 1.7. Calculate the current saturation field of the coarse scale by averaging the obtained fine-scale saturation field over coarse grid blocks.

Appendix 5: Vorticity-based Grid Generation Algorithm

Moving window technique was employed to generate vorticity-based coarse grids. The algorithm employs two independent moving windows in the $x$- and $y$-directions. The size of the windows was set to 2. In other words, each window contains two fine cells. The employed vorticity-based algorithm is as follows:

• 1. Get the desired coarse grid dimension, $N_{xc,d}$ and $N_{yc,d}$.

• 2. Perform the single-phase flow simulation to obtain the fine-scale velocity distribution.

• 3. Calculate the fine-scale vorticity distribution.

• 4. Initialize the $x$-direction cutoff, $CU_x=1$.

• 5. Set $N_{xc}=1$.

• 6. Sweep the $x$-direction window along and across the fine grid model and calculate the vorticity variation across the window. If the calculated difference is greater than the threshold $CU_x$, set the boundary between the two fine cells of the moving window as the coarse grid boundary and update $N_{xc}$.

• 7. If $N_{xc} > N_{xc,d}$, increase $CU_x$ and goto step 5.

• 8. If $N_{xc} < N_{xc,d}$, decrease $CU_x$ and goto step 5.

• 9. Set $N_{yc}=1$.

• 10. Sweep the $y$-direction window along and across the fine grid model and calculate the vorticity variation across the window. If the calculated difference is greater than the threshold $CU_y$, set the boundary between the two fine cells of the moving window as the coarse grid boundary and update $N_{yc}$.

• 11. If $N_{yc} > N_{yc,d}$, increase $CU_y$ and goto step 9.

• 12. If $N_{yc} < N_{yc,d}$, decrease $CU_y$ and goto step 9.

As can be concluded from the algorithm, the $x$- and $y$-direction cutoffs were not set manually as the algorithm tune them to yield the desired coarse grid dimension.

Appendix 6: Flow-based Grid Generation Algorithm

The flow-based grid generation algorithm is based on the idea that the volumetric flow rate through a coarse grid layer should not exceed a prescribed value. The employed flow-based algorithm is as follows:

• 1. Get the desired coarse grid dimension, $N_{xc,d}$ and $N_{yc,d}$.

• 2. Perform the single-phase flow simulation to obtain the fine-scale velocity distribution.

• 3. Initialize the $x$-direction cutoff, $CU_x=1$.

• 4. Set $N_{xc}=1$.

• 5. Sweep across the vertical fine grid layers (columns) and place the coarse grid boundaries, such that the volumetric flow rate through each vertical coarse layer does not exceed $CU_x$. Use $y$-direction velocity component to calculate the volumetric flow through the layers.

• 6. Update $N_{xc}$.

• 7. If $N_{xc} > N_{xc,d}$, increase $CU_x$ and goto step 4.

• 8. If $N_{xc} < N_{xc,d}$, decrease $CU_x$ and goto step 4.

• 9. Set $N_{yc}=1$.

• 10. Sweep across the horizontal fine grid layers (rows) and place the coarse grid boundaries, such that the volumetric flow rate through each horizontal coarse layer does not exceed $CU_y$. Use $x$-direction velocity component to calculate the volumetric flow through the layers.

• 11. Update $N_{yc}$.

• 12. If $N_{yc} > N_{yc,d}$, increase $CU_y$ and goto step 9.

• 13. If $N_{yc} < N_{yc,d}$, decrease $CU_y$ and goto step 9.