Пример #1
0
    def test_implicit_solve_reverse_boundary_conditions(self):

        self.inputs['boundary conditions'] = {
            'right': {
                'type': 'prescribed pressure',
                'value': 2000  #psi
            },
            'left': {
                'type': 'prescribed flux',
                'value': 0  #ft^3/day
            },
            'top': {
                'type': 'prescribed flux',
                'value': 0  #ft^3/day
            },
            'bottom': {
                'type': 'prescribed flux',
                'value': 0  #ft^3/day
            }
        }

        implicit = TwoPhaseFlow(self.inputs)
        implicit.solve()
        np.testing.assert_allclose(implicit.get_solution(),
                                   np.array([1015.9, 1051.5, 1184.8, 1582.9]),
                                   atol=0.5)
        return
Пример #2
0
    def test_implicit_solve(self):

        implicit = TwoPhaseFlow(self.inputs)
        implicit.solve()
        np.testing.assert_allclose(implicit.get_solution(),
                                   np.array([1582.9, 1184.8, 1051.5, 1015.9]),
                                   atol=0.5)
        return
Пример #3
0
    def test_IMPES_with_wells_solve(self):
        
        
        self.inputs['reservoir'] = {
                'permeability': 100, #mD
                'porosity': 0.2,
                'length': 1000, #ft
                'height': 10000, #ft
                'depth': 1, #ft
                'residual oil saturation': 0.2,
                'critical water saturation': 0.2,
                'oil': {
                    'residual saturation': 0.2,
                    'corey-brooks exponent': 3.0,
                    'max relative permeability': 1.0,
                },
                'water': {
                    'critical saturation': 0.2,
                    'corey-brooks exponent': 3.0,
                    'max relative permeability': 0.2,
                }
            }
        
        
        self.inputs['initial conditions'] = {
                  'water saturation': 0.2,
                  'pressure': 1000 #psi
              }
        
        self.inputs['fluid']['oil']['compressibility'] = 1e-5
        self.inputs['fluid']['water']['compressibility'] = 1e-5
        
        self.inputs['wells'] = {
                'rate': {
                        'locations': [(0.01, 0.01), (999.99, 0.01)],
                        'values': [426.5, -426.5],
                        'radii': [0.25, 0.25]
                    },
            }
        
        self.inputs['numerical']['number of grids'] = {'x': 3, 'y': 1}
        
        
        self.inputs['boundary conditions']['left']['type'] = 'prescribed flux'
        self.inputs['boundary conditions']['left']['value'] = 0.0
        
        implicit = TwoPhaseFlow(self.inputs)
        implicit.solve()
        np.testing.assert_allclose(implicit.saturation, 
                                   np.array([0.2019, 0.2, 0.2]),
                                   atol=0.0001)
        np.testing.assert_allclose(implicit.p, 
                                   np.array([1022.1, 999.9, 977.8]),
                                   atol=0.5)

        return
Пример #4
0
    def test_implicit_heterogeneous_permeability_and_grid_size_solve(self):

        self.inputs['reservoir']['permeability'] = [10., 100., 50., 20]
        self.inputs['numerical']['delta x'] = [2000., 3000., 1500., 3500]

        implicit = TwoPhaseFlow(self.inputs)
        implicit.solve()
        np.testing.assert_allclose(implicit.get_solution(),
                                   np.array([1295.6, 1039.1, 1019.9, 1002.5]),
                                   atol=0.5)
        return
Пример #5
0
    def test_mixed_method_solve_crank_nicolson(self):

        self.inputs['numerical']['solver'] = {'mixed method': {'theta': 0.5}}

        mixed = TwoPhaseFlow(self.inputs)

        mixed.solve()

        np.testing.assert_allclose(mixed.get_solution(),
                                   np.array([1642.0, 1196.5, 1043.8, 1009.1]),
                                   atol=0.5)
        return
Пример #6
0
    def test_explicit_solve(self):

        self.inputs['numerical']['solver'] = 'explicit'

        explicit = TwoPhaseFlow(self.inputs)

        explicit.solve()

        np.testing.assert_allclose(explicit.get_solution(),
                                   np.array([1689.8, 1222.3, 1032.4, 1000.0]),
                                   atol=0.5)
        return
Пример #7
0
 def test_implicit_solve_with_wells_1(self):
     
     
     self.inputs['wells'] = {
             'rate': {
                 'locations': [(0.0, 1.0)],
                 'values': [1000],
                 'radii': [0.25]
             },
             'bhp': {
                 'locations': [(6250.0, 1.0)],
                 'values': [800],
                 'radii': [0.25]
             }
         }
     
     self.inputs['reservoir'] = {
             'permeability': 50, #mD
             'porosity': 0.2,
             'length': 10000, #ft
             'height': 2500, #ft
             'depth': 80, #ft
             'oil': {
                 'residual saturation': 0.2,
                 'corey-brooks exponent': 3.0,
                 'max relative permeability': 0.0,
             },
             'water': {
                 'critical saturation': 0.2,
                 'corey-brooks exponent': 0.0,
                 'max relative permeability': 1.0,
             }
         }
     
     
     self.inputs['boundary conditions']['left']['type'] = 'prescribed flux'
     self.inputs['boundary conditions']['left']['value'] = 0.0
     self.inputs['boundary conditions']['right']['type'] = 'prescribed pressure'
     self.inputs['boundary conditions']['right']['value'] = 2000.0
     
     implicit = TwoPhaseFlow(self.inputs)
     implicit.solve()
     np.testing.assert_allclose(implicit.get_solution(), 
                                np.array([1028.9,  1031.6,  1096.7,  1563.7]),
                                atol=0.5)
     return