Beispiel #1
0
def test_gridgen():

    # define the base grid and then create a couple levels of nested
    # refinement
    Lx = 10000.
    Ly = 10500.
    nlay = 3
    nrow = 21
    ncol = 20
    delr = Lx / ncol
    delc = Ly / nrow
    top = 400
    botm = [220, 200, np.random.random((nrow, ncol))]

    # create a dummy dis package for gridgen
    ms = flopy.modflow.Modflow()
    dis5 = flopy.modflow.ModflowDis(ms,
                                    nlay=nlay,
                                    nrow=nrow,
                                    ncol=ncol,
                                    delr=delr,
                                    delc=delc,
                                    top=top,
                                    botm=botm)

    sim = flopy.mf6.MFSimulation()
    gwf = gwf = flopy.mf6.ModflowGwf(sim)
    dis6 = flopy.mf6.ModflowGwfdis(gwf,
                                   nlay=nlay,
                                   nrow=nrow,
                                   ncol=ncol,
                                   delr=delr,
                                   delc=delc,
                                   top=top,
                                   botm=botm)

    ms_u = flopy.modflow.Modflow(modelname='mymfusgmodel',
                                 model_ws=cpth,
                                 version='mfusg')
    dis_usg = flopy.modflow.ModflowDis(ms_u,
                                       nlay=nlay,
                                       nrow=nrow,
                                       ncol=ncol,
                                       delr=delr,
                                       delc=delc,
                                       top=top,
                                       botm=botm)

    gridgen_ws = cpth
    g = Gridgen(dis5, model_ws=gridgen_ws, exe_name=exe_name)
    g6 = Gridgen(dis6, model_ws=gridgen_ws, exe_name=exe_name)
    gu = Gridgen(dis_usg,
                 model_ws=gridgen_ws,
                 exe_name=exe_name,
                 vertical_pass_through=True)

    if shapefile is None:
        return  # skip remainder

    rf0shp = os.path.join(gridgen_ws, 'rf0')
    xmin = 7 * delr
    xmax = 12 * delr
    ymin = 8 * delc
    ymax = 13 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 1, range(nlay))
    g6.add_refinement_features(rfpoly, 'polygon', 1, range(nlay))
    gu.add_refinement_features(rfpoly, 'polygon', 1, range(nlay))

    rf1shp = os.path.join(gridgen_ws, 'rf1')
    xmin = 8 * delr
    xmax = 11 * delr
    ymin = 9 * delc
    ymax = 12 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 2, range(nlay))
    g6.add_refinement_features(rfpoly, 'polygon', 2, range(nlay))
    gu.add_refinement_features(rfpoly, 'polygon', 2, range(nlay))

    rf2shp = os.path.join(gridgen_ws, 'rf2')
    xmin = 9 * delr
    xmax = 10 * delr
    ymin = 10 * delc
    ymax = 11 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 3, range(nlay))
    g6.add_refinement_features(rfpoly, 'polygon', 3, range(nlay))
    gu.add_refinement_features(rfpoly, 'polygon', 3, range(nlay))

    # inactivate parts of mfusg layer 2 to test vertical-pass-through option
    xmin = 0 * delr
    xmax = 18 * delr
    ymin = 0 * delc
    ymax = 18 * delc
    adpoly2 = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                 (xmin, ymin)]]]
    gu.add_active_domain(adpoly2, layers=[1])
    adpoly1_3 = [[[(0., 0.), (Lx, 0.), (Lx, Ly), (0., Ly), (0., 0.)]]]
    gu.add_active_domain(adpoly1_3, layers=[0, 2])

    # if gridgen executable is available then do the main part of the test
    if run:

        # Use gridgen to build the grid
        g.build()
        g6.build()

        # test the different gridprops dictionaries, which contain all the
        # information needed to make the different discretization packages
        gridprops = g.get_gridprops_disv()
        gridprops = g.get_gridprops_disu5()
        gridprops = g.get_gridprops_disu6()

        # test the gridgen point intersection
        points = [(4750., 5250.)]
        cells = g.intersect(points, 'point', 0)
        n = cells['nodenumber'][0]
        msg = ('gridgen point intersect did not identify the correct '
               'cell {} <> {}'.format(n, 308))
        assert n == 308, msg

        # test the gridgen line intersection
        line = [[[(Lx, Ly), (Lx, 0.)]]]
        cells = g.intersect(line, 'line', 0)
        nlist = [n for n in cells['nodenumber']]
        nlist2 = [
            19, 650, 39, 630, 59, 610, 79, 590, 99, 570, 119, 550, 139, 530,
            159, 510, 194, 490, 265, 455, 384
        ]
        msg = ('gridgen line intersect did not identify the correct '
               'cells {} <> {}'.format(nlist, nlist2))
        assert nlist == nlist2, msg

        # test getting a modflow-usg disu package
        mu = flopy.modflow.Modflow(version='mfusg', structured=False)
        disu = g.get_disu(mu)

        # test mfusg with vertical pass-through (True above at instantiation)
        gu.build()
        disu_vp = gu.get_disu(ms_u)
        #  -check that node 1 (layer 1) is connected to layer 3 but not layer 2:
        ja0 = disu_vp.ja[:disu_vp.iac[0]]
        msg = ("MFUSG node 1 (layer 1) is not connected to layer 3 but should "
               "be (with vertical pass through activated).")
        assert max(ja0) > sum(disu_vp.nodelay[:2]), msg
        #  -check that node 1 (layer 1) is not connected to any layer 2 nodes
        msg = ("MFUSG node 1 (layer 1) is connected to layer 2 but should not "
               "be (with vertical pass through activated).")
        assert len(ja0[(ja0 > disu_vp.nodelay[0]) & \
                       (ja0 <= sum(disu_vp.nodelay[:2]))]
                   ) == 0, msg
        #ms_u.disu.write_file()

        # test mfusg without vertical pass-through
        gu.vertical_pass_through = False
        gu.build()
        disu_vp = gu.get_disu(ms_u)
        #  -check that node 1 (layer 1) is connected to layer 1 only:
        ja0 = disu_vp.ja[:disu_vp.iac[0]]
        msg = ("MFUSG node 1 (layer 1) is connected to layer 2 or 3 but "
               "should not be (without vertical pass through activated).")
        assert max(ja0) <= disu_vp.nodelay[0], msg

    return
Beispiel #2
0
def run():
    # run installed version of flopy or add local path
    try:
        import flopy
    except:
        fpth = os.path.abspath(os.path.join('..', '..'))
        sys.path.append(fpth)
        import flopy

    # Set name of MODFLOW exe
    #  assumes executable is in users path statement
    version = 'mf2005'
    exe_name = 'mf2005'
    exe_mp = 'mp6'
    if platform.system() == 'Windows':
        exe_name += '.exe'
        exe_mp += '.exe'
    mfexe = exe_name

    # Set the paths
    loadpth = os.path.join('..', 'data', 'freyberg')
    modelpth = os.path.join('data')

    # make sure modelpth directory exists
    if not os.path.exists(modelpth):
        os.makedirs(modelpth)

    ml = flopy.modflow.Modflow.load('freyberg.nam',
                                    model_ws=loadpth,
                                    exe_name=exe_name,
                                    version=version)
    ml.change_model_ws(new_pth=modelpth)
    ml.write_input()
    success, buff = ml.run_model()
    if not success:
        print('Something bad happened.')
    files = ['freyberg.hds', 'freyberg.cbc']
    for f in files:
        if os.path.isfile(os.path.join(modelpth, f)):
            msg = 'Output file located: {}'.format(f)
            print(msg)
        else:
            errmsg = 'Error. Output file cannot be found: {}'.format(f)
            print(errmsg)

    mp = flopy.modpath.Modpath('freybergmp',
                               exe_name=exe_mp,
                               modflowmodel=ml,
                               model_ws=modelpth)
    mpbas = flopy.modpath.ModpathBas(mp,
                                     hnoflo=ml.bas6.hnoflo,
                                     hdry=ml.lpf.hdry,
                                     ibound=ml.bas6.ibound.array,
                                     prsity=0.2,
                                     prsityCB=0.2)
    sim = mp.create_mpsim(trackdir='forward',
                          simtype='endpoint',
                          packages='RCH')
    mp.write_input()
    mp.run_model()

    mpp = flopy.modpath.Modpath('freybergmpp',
                                exe_name=exe_mp,
                                modflowmodel=ml,
                                model_ws=modelpth)
    mpbas = flopy.modpath.ModpathBas(mpp,
                                     hnoflo=ml.bas6.hnoflo,
                                     hdry=ml.lpf.hdry,
                                     ibound=ml.bas6.ibound.array,
                                     prsity=0.2,
                                     prsityCB=0.2)
    sim = mpp.create_mpsim(trackdir='backward',
                           simtype='pathline',
                           packages='WEL')
    mpp.write_input()
    mpp.run_model()

    ## load and run second example
    # run installed version of flopy or add local path
    try:
        import flopy
    except:
        fpth = os.path.abspath(os.path.join('..', '..'))
        sys.path.append(fpth)
        import flopy

        print(sys.version)
    print('numpy version: {}'.format(np.__version__))
    print('matplotlib version: {}'.format(mpl.__version__))
    print('flopy version: {}'.format(flopy.__version__))

    if not os.path.exists("data"):
        os.mkdir("data")

    from flopy.utils.gridgen import Gridgen
    Lx = 10000.
    Ly = 10500.
    nlay = 3
    nrow = 21
    ncol = 20
    delr = Lx / ncol
    delc = Ly / nrow
    top = 400
    botm = [220, 200, 0]

    ms = flopy.modflow.Modflow()
    dis5 = flopy.modflow.ModflowDis(ms,
                                    nlay=nlay,
                                    nrow=nrow,
                                    ncol=ncol,
                                    delr=delr,
                                    delc=delc,
                                    top=top,
                                    botm=botm)

    model_name = 'mp7p2'
    model_ws = os.path.join('data', 'mp7_ex2', 'mf6')
    gridgen_ws = os.path.join(model_ws, 'gridgen')
    g = Gridgen(dis5, model_ws=gridgen_ws)

    rf0shp = os.path.join(gridgen_ws, 'rf0')
    xmin = 7 * delr
    xmax = 12 * delr
    ymin = 8 * delc
    ymax = 13 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 1, range(nlay))

    rf1shp = os.path.join(gridgen_ws, 'rf1')
    xmin = 8 * delr
    xmax = 11 * delr
    ymin = 9 * delc
    ymax = 12 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 2, range(nlay))

    rf2shp = os.path.join(gridgen_ws, 'rf2')
    xmin = 9 * delr
    xmax = 10 * delr
    ymin = 10 * delc
    ymax = 11 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 3, range(nlay))

    g.build(verbose=False)

    gridprops = g.get_gridprops_disv()
    ncpl = gridprops['ncpl']
    top = gridprops['top']
    botm = gridprops['botm']
    nvert = gridprops['nvert']
    vertices = gridprops['vertices']
    cell2d = gridprops['cell2d']
    # cellxy = gridprops['cellxy']

    # create simulation
    sim = flopy.mf6.MFSimulation(sim_name=model_name,
                                 version='mf6',
                                 exe_name='mf6',
                                 sim_ws=model_ws)

    # create tdis package
    tdis_rc = [(1000.0, 1, 1.0)]
    tdis = flopy.mf6.ModflowTdis(sim,
                                 pname='tdis',
                                 time_units='DAYS',
                                 perioddata=tdis_rc)

    # create gwf model
    gwf = flopy.mf6.ModflowGwf(sim,
                               modelname=model_name,
                               model_nam_file='{}.nam'.format(model_name))
    gwf.name_file.save_flows = True

    # create iterative model solution and register the gwf model with it
    ims = flopy.mf6.ModflowIms(sim,
                               pname='ims',
                               print_option='SUMMARY',
                               complexity='SIMPLE',
                               outer_hclose=1.e-5,
                               outer_maximum=100,
                               under_relaxation='NONE',
                               inner_maximum=100,
                               inner_hclose=1.e-6,
                               rcloserecord=0.1,
                               linear_acceleration='BICGSTAB',
                               scaling_method='NONE',
                               reordering_method='NONE',
                               relaxation_factor=0.99)
    sim.register_ims_package(ims, [gwf.name])

    # disv
    disv = flopy.mf6.ModflowGwfdisv(gwf,
                                    nlay=nlay,
                                    ncpl=ncpl,
                                    top=top,
                                    botm=botm,
                                    nvert=nvert,
                                    vertices=vertices,
                                    cell2d=cell2d)

    # initial conditions
    ic = flopy.mf6.ModflowGwfic(gwf, pname='ic', strt=320.)

    # node property flow
    npf = flopy.mf6.ModflowGwfnpf(gwf,
                                  xt3doptions=[('xt3d')],
                                  icelltype=[1, 0, 0],
                                  k=[50.0, 0.01, 200.0],
                                  k33=[10., 0.01, 20.])

    # wel
    wellpoints = [(4750., 5250.)]
    welcells = g.intersect(wellpoints, 'point', 0)
    # welspd = flopy.mf6.ModflowGwfwel.stress_period_data.empty(gwf, maxbound=1, aux_vars=['iface'])
    welspd = [[(2, icpl), -150000, 0] for icpl in welcells['nodenumber']]
    wel = flopy.mf6.ModflowGwfwel(gwf,
                                  print_input=True,
                                  auxiliary=[('iface', )],
                                  stress_period_data=welspd)

    # rch
    aux = [np.ones(ncpl, dtype=np.int) * 6]
    rch = flopy.mf6.ModflowGwfrcha(gwf,
                                   recharge=0.005,
                                   auxiliary=[('iface', )],
                                   aux={0: [6]})
    # riv
    riverline = [[[(Lx - 1., Ly), (Lx - 1., 0.)]]]
    rivcells = g.intersect(riverline, 'line', 0)
    rivspd = [[(0, icpl), 320., 100000., 318]
              for icpl in rivcells['nodenumber']]
    riv = flopy.mf6.ModflowGwfriv(gwf, stress_period_data=rivspd)

    # output control
    oc = flopy.mf6.ModflowGwfoc(gwf,
                                pname='oc',
                                budget_filerecord='{}.cbb'.format(model_name),
                                head_filerecord='{}.hds'.format(model_name),
                                headprintrecord=[('COLUMNS', 10, 'WIDTH', 15,
                                                  'DIGITS', 6, 'GENERAL')],
                                saverecord=[('HEAD', 'ALL'),
                                            ('BUDGET', 'ALL')],
                                printrecord=[('HEAD', 'ALL'),
                                             ('BUDGET', 'ALL')])

    sim.write_simulation()
    sim.run_simulation()

    mp_namea = model_name + 'a_mp'
    mp_nameb = model_name + 'b_mp'

    pcoord = np.array([[0.000, 0.125, 0.500], [0.000, 0.375, 0.500],
                       [0.000, 0.625, 0.500], [0.000, 0.875, 0.500],
                       [1.000, 0.125, 0.500], [1.000, 0.375, 0.500],
                       [1.000, 0.625, 0.500], [1.000, 0.875, 0.500],
                       [0.125, 0.000, 0.500], [0.375, 0.000, 0.500],
                       [0.625, 0.000, 0.500], [0.875, 0.000, 0.500],
                       [0.125, 1.000, 0.500], [0.375, 1.000, 0.500],
                       [0.625, 1.000, 0.500], [0.875, 1.000, 0.500]])
    nodew = gwf.disv.ncpl.array * 2 + welcells['nodenumber'][0]
    plocs = [nodew for i in range(pcoord.shape[0])]

    # create particle data
    pa = flopy.modpath.ParticleData(plocs,
                                    structured=False,
                                    localx=pcoord[:, 0],
                                    localy=pcoord[:, 1],
                                    localz=pcoord[:, 2],
                                    drape=0)

    # create backward particle group
    fpth = mp_namea + '.sloc'
    pga = flopy.modpath.ParticleGroup(particlegroupname='BACKWARD1',
                                      particledata=pa,
                                      filename=fpth)

    facedata = flopy.modpath.FaceDataType(drape=0,
                                          verticaldivisions1=10,
                                          horizontaldivisions1=10,
                                          verticaldivisions2=10,
                                          horizontaldivisions2=10,
                                          verticaldivisions3=10,
                                          horizontaldivisions3=10,
                                          verticaldivisions4=10,
                                          horizontaldivisions4=10,
                                          rowdivisions5=0,
                                          columndivisions5=0,
                                          rowdivisions6=4,
                                          columndivisions6=4)
    pb = flopy.modpath.NodeParticleData(subdivisiondata=facedata, nodes=nodew)
    # create forward particle group
    fpth = mp_nameb + '.sloc'
    pgb = flopy.modpath.ParticleGroupNodeTemplate(
        particlegroupname='BACKWARD2', particledata=pb, filename=fpth)

    # create modpath files
    mp = flopy.modpath.Modpath7(modelname=mp_namea,
                                flowmodel=gwf,
                                exe_name='mp7',
                                model_ws=model_ws)
    flopy.modpath.Modpath7Bas(mp, porosity=0.1)
    flopy.modpath.Modpath7Sim(mp,
                              simulationtype='combined',
                              trackingdirection='backward',
                              weaksinkoption='pass_through',
                              weaksourceoption='pass_through',
                              referencetime=0.,
                              stoptimeoption='extend',
                              timepointdata=[500, 1000.],
                              particlegroups=pga)

    # write modpath datasets
    mp.write_input()

    # run modpath
    mp.run_model()

    # create modpath files
    mp = flopy.modpath.Modpath7(modelname=mp_nameb,
                                flowmodel=gwf,
                                exe_name='mp7',
                                model_ws=model_ws)
    flopy.modpath.Modpath7Bas(mp, porosity=0.1)
    flopy.modpath.Modpath7Sim(mp,
                              simulationtype='endpoint',
                              trackingdirection='backward',
                              weaksinkoption='pass_through',
                              weaksourceoption='pass_through',
                              referencetime=0.,
                              stoptimeoption='extend',
                              particlegroups=pgb)

    # write modpath datasets
    mp.write_input()

    # run modpath
    mp.run_model()
    return
Beispiel #3
0
def run():
    # run installed version of flopy or add local path
    try:
        import flopy
    except:
        fpth = os.path.abspath(os.path.join('..', '..'))
        sys.path.append(fpth)
        import flopy

    # Set name of MODFLOW exe
    #  assumes executable is in users path statement
    version = 'mf2005'
    exe_name = 'mf2005'
    exe_mp = 'mp6'
    if platform.system() == 'Windows':
        exe_name += '.exe'
        exe_mp += '.exe'
    mfexe = exe_name

    # Set the paths
    loadpth = os.path.join('..', 'data', 'freyberg')
    modelpth = os.path.join('data')

    # make sure modelpth directory exists
    if not os.path.exists(modelpth):
        os.makedirs(modelpth)

    ml = flopy.modflow.Modflow.load('freyberg.nam', model_ws=loadpth,
                                    exe_name=exe_name, version=version)
    ml.change_model_ws(new_pth=modelpth)
    ml.write_input()
    success, buff = ml.run_model()
    if not success:
        print('Something bad happened.')
    files = ['freyberg.hds', 'freyberg.cbc']
    for f in files:
        if os.path.isfile(os.path.join(modelpth, f)):
            msg = 'Output file located: {}'.format(f)
            print(msg)
        else:
            errmsg = 'Error. Output file cannot be found: {}'.format(f)
            print(errmsg)

    mp = flopy.modpath.Modpath('freybergmp', exe_name=exe_mp, modflowmodel=ml, model_ws=modelpth)
    mpbas = flopy.modpath.ModpathBas(mp, hnoflo=ml.bas6.hnoflo, hdry=ml.lpf.hdry,
                                     ibound=ml.bas6.ibound.array, prsity=0.2, prsityCB=0.2)
    sim = mp.create_mpsim(trackdir='forward', simtype='endpoint', packages='RCH')
    mp.write_input()
    mp.run_model()

    mpp = flopy.modpath.Modpath('freybergmpp', exe_name=exe_mp, modflowmodel=ml, model_ws=modelpth)
    mpbas = flopy.modpath.ModpathBas(mpp, hnoflo=ml.bas6.hnoflo, hdry=ml.lpf.hdry,
                                     ibound=ml.bas6.ibound.array, prsity=0.2, prsityCB=0.2)
    sim = mpp.create_mpsim(trackdir='backward', simtype='pathline', packages='WEL')
    mpp.write_input()
    mpp.run_model()


    ## load and run second example
    # run installed version of flopy or add local path
    try:
        import flopy
    except:
        fpth = os.path.abspath(os.path.join('..', '..'))
        sys.path.append(fpth)
        import flopy

        print(sys.version)
    print('numpy version: {}'.format(np.__version__))
    print('matplotlib version: {}'.format(mpl.__version__))
    print('flopy version: {}'.format(flopy.__version__))

    if not os.path.exists("data"):
        os.mkdir("data")

    from flopy.utils.gridgen import Gridgen
    Lx = 10000.
    Ly = 10500.
    nlay = 3
    nrow = 21
    ncol = 20
    delr = Lx / ncol
    delc = Ly / nrow
    top = 400
    botm = [220, 200, 0]

    ms = flopy.modflow.Modflow()
    dis5 = flopy.modflow.ModflowDis(ms, nlay=nlay, nrow=nrow, ncol=ncol, delr=delr,
                                    delc=delc, top=top, botm=botm)

    model_name = 'mp7p2'
    model_ws = os.path.join('data', 'mp7_ex2', 'mf6')
    gridgen_ws = os.path.join(model_ws, 'gridgen')
    g = Gridgen(dis5, model_ws=gridgen_ws)

    rf0shp = os.path.join(gridgen_ws, 'rf0')
    xmin = 7 * delr
    xmax = 12 * delr
    ymin = 8 * delc
    ymax = 13 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax), (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 1, range(nlay))

    rf1shp = os.path.join(gridgen_ws, 'rf1')
    xmin = 8 * delr
    xmax = 11 * delr
    ymin = 9 * delc
    ymax = 12 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax), (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 2, range(nlay))

    rf2shp = os.path.join(gridgen_ws, 'rf2')
    xmin = 9 * delr
    xmax = 10 * delr
    ymin = 10 * delc
    ymax = 11 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax), (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 3, range(nlay))

    g.build(verbose=False)

    gridprops = g.get_gridprops_disv()
    ncpl = gridprops['ncpl']
    top = gridprops['top']
    botm = gridprops['botm']
    nvert = gridprops['nvert']
    vertices = gridprops['vertices']
    cell2d = gridprops['cell2d']
    # cellxy = gridprops['cellxy']

    # create simulation
    sim = flopy.mf6.MFSimulation(sim_name=model_name, version='mf6', exe_name='mf6',
                                 sim_ws=model_ws)

    # create tdis package
    tdis_rc = [(1000.0, 1, 1.0)]
    tdis = flopy.mf6.ModflowTdis(sim, pname='tdis', time_units='DAYS',
                                 perioddata=tdis_rc)

    # create gwf model
    gwf = flopy.mf6.ModflowGwf(sim, modelname=model_name,
                               model_nam_file='{}.nam'.format(model_name))
    gwf.name_file.save_flows = True

    # create iterative model solution and register the gwf model with it
    ims = flopy.mf6.ModflowIms(sim, pname='ims', print_option='SUMMARY',
                               complexity='SIMPLE', outer_hclose=1.e-5,
                               outer_maximum=100, under_relaxation='NONE',
                               inner_maximum=100, inner_hclose=1.e-6,
                               rcloserecord=0.1, linear_acceleration='BICGSTAB',
                               scaling_method='NONE', reordering_method='NONE',
                               relaxation_factor=0.99)
    sim.register_ims_package(ims, [gwf.name])

    # disv
    disv = flopy.mf6.ModflowGwfdisv(gwf, nlay=nlay, ncpl=ncpl,
                                    top=top, botm=botm,
                                    nvert=nvert, vertices=vertices,
                                    cell2d=cell2d)

    # initial conditions
    ic = flopy.mf6.ModflowGwfic(gwf, pname='ic', strt=320.)

    # node property flow
    npf = flopy.mf6.ModflowGwfnpf(gwf, xt3doptions=[('xt3d')],
                                  icelltype=[1, 0, 0],
                                  k=[50.0, 0.01, 200.0],
                                  k33=[10., 0.01, 20.])

    # wel
    wellpoints = [(4750., 5250.)]
    welcells = g.intersect(wellpoints, 'point', 0)
    # welspd = flopy.mf6.ModflowGwfwel.stress_period_data.empty(gwf, maxbound=1, aux_vars=['iface'])
    welspd = [[(2, icpl), -150000, 0] for icpl in welcells['nodenumber']]
    wel = flopy.mf6.ModflowGwfwel(gwf, print_input=True,
                                  auxiliary=[('iface',)],
                                  stress_period_data=welspd)

    # rch
    aux = [np.ones(ncpl, dtype=np.int) * 6]
    rch = flopy.mf6.ModflowGwfrcha(gwf, recharge=0.005,
                                   auxiliary=[('iface',)],
                                   aux={0: [6]})
    # riv
    riverline = [[[(Lx - 1., Ly), (Lx - 1., 0.)]]]
    rivcells = g.intersect(riverline, 'line', 0)
    rivspd = [[(0, icpl), 320., 100000., 318] for icpl in rivcells['nodenumber']]
    riv = flopy.mf6.ModflowGwfriv(gwf, stress_period_data=rivspd)

    # output control
    oc = flopy.mf6.ModflowGwfoc(gwf, pname='oc', budget_filerecord='{}.cbb'.format(model_name),
                                head_filerecord='{}.hds'.format(model_name),
                                headprintrecord=[('COLUMNS', 10, 'WIDTH', 15,
                                                  'DIGITS', 6, 'GENERAL')],
                                saverecord=[('HEAD', 'ALL'), ('BUDGET', 'ALL')],
                                printrecord=[('HEAD', 'ALL'), ('BUDGET', 'ALL')])

    sim.write_simulation()
    sim.run_simulation()

    mp_namea = model_name + 'a_mp'
    mp_nameb = model_name + 'b_mp'

    pcoord = np.array([[0.000, 0.125, 0.500],
                       [0.000, 0.375, 0.500],
                       [0.000, 0.625, 0.500],
                       [0.000, 0.875, 0.500],
                       [1.000, 0.125, 0.500],
                       [1.000, 0.375, 0.500],
                       [1.000, 0.625, 0.500],
                       [1.000, 0.875, 0.500],
                       [0.125, 0.000, 0.500],
                       [0.375, 0.000, 0.500],
                       [0.625, 0.000, 0.500],
                       [0.875, 0.000, 0.500],
                       [0.125, 1.000, 0.500],
                       [0.375, 1.000, 0.500],
                       [0.625, 1.000, 0.500],
                       [0.875, 1.000, 0.500]])
    nodew = gwf.disv.ncpl.array * 2 + welcells['nodenumber'][0]
    plocs = [nodew for i in range(pcoord.shape[0])]

    # create particle data
    pa = flopy.modpath.ParticleData(plocs, structured=False,
                                    localx=pcoord[:, 0],
                                    localy=pcoord[:, 1],
                                    localz=pcoord[:, 2],
                                    drape=0)

    # create backward particle group
    fpth = mp_namea + '.sloc'
    pga = flopy.modpath.ParticleGroup(particlegroupname='BACKWARD1', particledata=pa,
                                      filename=fpth)

    facedata = flopy.modpath.FaceDataType(drape=0,
                                          verticaldivisions1=10, horizontaldivisions1=10,
                                          verticaldivisions2=10, horizontaldivisions2=10,
                                          verticaldivisions3=10, horizontaldivisions3=10,
                                          verticaldivisions4=10, horizontaldivisions4=10,
                                          rowdivisions5=0, columndivisions5=0,
                                          rowdivisions6=4, columndivisions6=4)
    pb = flopy.modpath.NodeParticleData(subdivisiondata=facedata, nodes=nodew)
    # create forward particle group
    fpth = mp_nameb + '.sloc'
    pgb = flopy.modpath.ParticleGroupNodeTemplate(particlegroupname='BACKWARD2',
                                                  particledata=pb,
                                                  filename=fpth)

    # create modpath files
    mp = flopy.modpath.Modpath7(modelname=mp_namea, flowmodel=gwf,
                                exe_name='mp7', model_ws=model_ws)
    flopy.modpath.Modpath7Bas(mp, porosity=0.1)
    flopy.modpath.Modpath7Sim(mp, simulationtype='combined',
                              trackingdirection='backward',
                              weaksinkoption='pass_through',
                              weaksourceoption='pass_through',
                              referencetime=0.,
                              stoptimeoption='extend',
                              timepointdata=[500, 1000.],
                              particlegroups=pga)

    # write modpath datasets
    mp.write_input()

    # run modpath
    mp.run_model()

    # create modpath files
    mp = flopy.modpath.Modpath7(modelname=mp_nameb, flowmodel=gwf,
                                exe_name='mp7', model_ws=model_ws)
    flopy.modpath.Modpath7Bas(mp, porosity=0.1)
    flopy.modpath.Modpath7Sim(mp, simulationtype='endpoint',
                              trackingdirection='backward',
                              weaksinkoption='pass_through',
                              weaksourceoption='pass_through',
                              referencetime=0.,
                              stoptimeoption='extend',
                              particlegroups=pgb)

    # write modpath datasets
    mp.write_input()

    # run modpath
    mp.run_model()
    return
Beispiel #4
0
def test_mf6disv():

    if gridgen_exe is None:
        print(
            "Unable to run test_mf6disv(). Gridgen executable not available.")
        return

    if Polygon is None:
        print("Unable to run test_mf6disv(). shapely is not available.")
        return

    name = "dummy"
    nlay = 3
    nrow = 10
    ncol = 10
    delr = delc = 1.0
    top = 1
    bot = 0
    dz = (top - bot) / nlay
    botm = [top - k * dz for k in range(1, nlay + 1)]

    # Create a dummy model and regular grid to use as the base grid for gridgen
    sim = flopy.mf6.MFSimulation(sim_name=name,
                                 sim_ws=gridgen_ws,
                                 exe_name="mf6")
    gwf = flopy.mf6.ModflowGwf(sim, modelname=name)

    dis = flopy.mf6.ModflowGwfdis(
        gwf,
        nlay=nlay,
        nrow=nrow,
        ncol=ncol,
        delr=delr,
        delc=delc,
        top=top,
        botm=botm,
    )

    # Create and build the gridgen model with a refined area in the middle
    g = Gridgen(dis, model_ws=gridgen_ws)
    polys = [Polygon([(4, 4), (6, 4), (6, 6), (4, 6)])]
    g.add_refinement_features(polys, "polygon", 3, range(nlay))
    g.build()
    disv_gridprops = g.get_gridprops_disv()

    # find the cell numbers for constant heads
    chdspd = []
    ilay = 0
    for x, y, head in [(0, 10, 1.0), (10, 0, 0.0)]:
        ra = g.intersect([(x, y)], "point", ilay)
        ic = ra["nodenumber"][0]
        chdspd.append([(ilay, ic), head])

    # build run and post-process the MODFLOW 6 model
    ws = os.path.join(tpth, "gridgen_disv")
    name = "mymodel"
    sim = flopy.mf6.MFSimulation(
        sim_name=name,
        sim_ws=ws,
        exe_name="mf6",
        verbosity_level=VERBOSITY_LEVEL,
    )
    tdis = flopy.mf6.ModflowTdis(sim)
    ims = flopy.mf6.ModflowIms(sim, linear_acceleration="bicgstab")
    gwf = flopy.mf6.ModflowGwf(sim, modelname=name, save_flows=True)
    disv = flopy.mf6.ModflowGwfdisv(gwf, **disv_gridprops)
    ic = flopy.mf6.ModflowGwfic(gwf)
    npf = flopy.mf6.ModflowGwfnpf(gwf,
                                  xt3doptions=True,
                                  save_specific_discharge=True)
    chd = flopy.mf6.ModflowGwfchd(gwf, stress_period_data=chdspd)
    budget_file = name + ".bud"
    head_file = name + ".hds"
    oc = flopy.mf6.ModflowGwfoc(
        gwf,
        budget_filerecord=budget_file,
        head_filerecord=head_file,
        saverecord=[("HEAD", "ALL"), ("BUDGET", "ALL")],
    )
    sim.write_simulation()

    gwf.modelgrid.set_coord_info(angrot=15)

    # write grid and model shapefiles
    fname = os.path.join(ws, "grid.shp")
    gwf.modelgrid.write_shapefile(fname)
    fname = os.path.join(ws, "model.shp")
    gwf.export(fname)

    if mf6_exe is not None:
        sim.run_simulation(silent=True)
        head = flopy.utils.HeadFile(os.path.join(ws, head_file)).get_data()
        bud = flopy.utils.CellBudgetFile(os.path.join(ws, budget_file),
                                         precision="double")
        spdis = bud.get_data(text="DATA-SPDIS")[0]

        if matplotlib is not None:
            f = plt.figure(figsize=(10, 10))
            vmin = head.min()
            vmax = head.max()
            for ilay in range(gwf.modelgrid.nlay):
                ax = plt.subplot(1, gwf.modelgrid.nlay, ilay + 1)
                pmv = flopy.plot.PlotMapView(gwf, layer=ilay, ax=ax)
                ax.set_aspect("equal")
                pmv.plot_array(head.flatten(),
                               cmap="jet",
                               vmin=vmin,
                               vmax=vmax)
                pmv.plot_grid(colors="k", alpha=0.1)
                pmv.contour_array(
                    head,
                    levels=[0.2, 0.4, 0.6, 0.8],
                    linewidths=3.0,
                    vmin=vmin,
                    vmax=vmax,
                )
                ax.set_title("Layer {}".format(ilay + 1))
                pmv.plot_specific_discharge(spdis, color="white")
            fname = "results.png"
            fname = os.path.join(ws, fname)
            plt.savefig(fname)
            plt.close("all")

    return
Beispiel #5
0
def run():
    ## load and run vertex grid example
    # run installed version of flopy or add local path
    try:
        import flopy
    except:
        fpth = os.path.abspath(os.path.join("../..", ".."))
        sys.path.append(fpth)
        import flopy

        print(sys.version)
    print("numpy version: {}".format(np.__version__))
    print("matplotlib version: {}".format(mpl.__version__))
    print("flopy version: {}".format(flopy.__version__))

    if not os.path.exists("data"):
        os.mkdir("data")

    from flopy.utils.gridgen import Gridgen

    Lx = 10000.0
    Ly = 10500.0
    nlay = 3
    nrow = 21
    ncol = 20
    delr = Lx / ncol
    delc = Ly / nrow
    top = 400
    botm = [220, 200, 0]

    ms = flopy.modflow.Modflow()
    dis5 = flopy.modflow.ModflowDis(
        ms,
        nlay=nlay,
        nrow=nrow,
        ncol=ncol,
        delr=delr,
        delc=delc,
        top=top,
        botm=botm,
    )

    model_name = "mp7p2"
    model_ws = os.path.join("data", "mp7_ex2", "mf6")
    gridgen_ws = os.path.join(model_ws, "gridgen")
    g = Gridgen(dis5, model_ws=gridgen_ws)

    rf0shp = os.path.join(gridgen_ws, "rf0")
    xmin = 7 * delr
    xmax = 12 * delr
    ymin = 8 * delc
    ymax = 13 * delc
    rfpoly = [[[
        (xmin, ymin),
        (xmax, ymin),
        (xmax, ymax),
        (xmin, ymax),
        (xmin, ymin),
    ]]]
    g.add_refinement_features(rfpoly, "polygon", 1, range(nlay))

    rf1shp = os.path.join(gridgen_ws, "rf1")
    xmin = 8 * delr
    xmax = 11 * delr
    ymin = 9 * delc
    ymax = 12 * delc
    rfpoly = [[[
        (xmin, ymin),
        (xmax, ymin),
        (xmax, ymax),
        (xmin, ymax),
        (xmin, ymin),
    ]]]
    g.add_refinement_features(rfpoly, "polygon", 2, range(nlay))

    rf2shp = os.path.join(gridgen_ws, "rf2")
    xmin = 9 * delr
    xmax = 10 * delr
    ymin = 10 * delc
    ymax = 11 * delc
    rfpoly = [[[
        (xmin, ymin),
        (xmax, ymin),
        (xmax, ymax),
        (xmin, ymax),
        (xmin, ymin),
    ]]]
    g.add_refinement_features(rfpoly, "polygon", 3, range(nlay))

    g.build(verbose=False)

    gridprops = g.get_gridprops_disv()
    ncpl = gridprops["ncpl"]
    top = gridprops["top"]
    botm = gridprops["botm"]
    nvert = gridprops["nvert"]
    vertices = gridprops["vertices"]
    cell2d = gridprops["cell2d"]
    # cellxy = gridprops['cellxy']

    # create simulation
    sim = flopy.mf6.MFSimulation(sim_name=model_name,
                                 version="mf6",
                                 exe_name="mf6",
                                 sim_ws=model_ws)

    # create tdis package
    tdis_rc = [(1000.0, 1, 1.0)]
    tdis = flopy.mf6.ModflowTdis(sim,
                                 pname="tdis",
                                 time_units="DAYS",
                                 perioddata=tdis_rc)

    # create gwf model
    gwf = flopy.mf6.ModflowGwf(sim,
                               modelname=model_name,
                               model_nam_file="{}.nam".format(model_name))
    gwf.name_file.save_flows = True

    # create iterative model solution and register the gwf model with it
    ims = flopy.mf6.ModflowIms(
        sim,
        pname="ims",
        print_option="SUMMARY",
        complexity="SIMPLE",
        outer_hclose=1.0e-5,
        outer_maximum=100,
        under_relaxation="NONE",
        inner_maximum=100,
        inner_hclose=1.0e-6,
        rcloserecord=0.1,
        linear_acceleration="BICGSTAB",
        scaling_method="NONE",
        reordering_method="NONE",
        relaxation_factor=0.99,
    )
    sim.register_ims_package(ims, [gwf.name])

    # disv
    disv = flopy.mf6.ModflowGwfdisv(
        gwf,
        nlay=nlay,
        ncpl=ncpl,
        top=top,
        botm=botm,
        nvert=nvert,
        vertices=vertices,
        cell2d=cell2d,
    )

    # initial conditions
    ic = flopy.mf6.ModflowGwfic(gwf, pname="ic", strt=320.0)

    # node property flow
    npf = flopy.mf6.ModflowGwfnpf(
        gwf,
        xt3doptions=[("xt3d")],
        save_specific_discharge=True,
        icelltype=[1, 0, 0],
        k=[50.0, 0.01, 200.0],
        k33=[10.0, 0.01, 20.0],
    )

    # wel
    wellpoints = [(4750.0, 5250.0)]
    welcells = g.intersect(wellpoints, "point", 0)
    # welspd = flopy.mf6.ModflowGwfwel.stress_period_data.empty(gwf, maxbound=1, aux_vars=['iface'])
    welspd = [[(2, icpl), -150000, 0] for icpl in welcells["nodenumber"]]
    wel = flopy.mf6.ModflowGwfwel(
        gwf,
        print_input=True,
        auxiliary=[("iface", )],
        stress_period_data=welspd,
    )

    # rch
    aux = [np.ones(ncpl, dtype=int) * 6]
    rch = flopy.mf6.ModflowGwfrcha(gwf,
                                   recharge=0.005,
                                   auxiliary=[("iface", )],
                                   aux={0: [6]})
    # riv
    riverline = [[[(Lx - 1.0, Ly), (Lx - 1.0, 0.0)]]]
    rivcells = g.intersect(riverline, "line", 0)
    rivspd = [[(0, icpl), 320.0, 100000.0, 318]
              for icpl in rivcells["nodenumber"]]
    riv = flopy.mf6.ModflowGwfriv(gwf, stress_period_data=rivspd)

    # output control
    oc = flopy.mf6.ModflowGwfoc(
        gwf,
        pname="oc",
        budget_filerecord="{}.cbb".format(model_name),
        head_filerecord="{}.hds".format(model_name),
        headprintrecord=[("COLUMNS", 10, "WIDTH", 15, "DIGITS", 6, "GENERAL")],
        saverecord=[("HEAD", "ALL"), ("BUDGET", "ALL")],
        printrecord=[("HEAD", "ALL"), ("BUDGET", "ALL")],
    )

    sim.write_simulation()
    sim.run_simulation()

    mp_namea = model_name + "a_mp"
    mp_nameb = model_name + "b_mp"

    pcoord = np.array([
        [0.000, 0.125, 0.500],
        [0.000, 0.375, 0.500],
        [0.000, 0.625, 0.500],
        [0.000, 0.875, 0.500],
        [1.000, 0.125, 0.500],
        [1.000, 0.375, 0.500],
        [1.000, 0.625, 0.500],
        [1.000, 0.875, 0.500],
        [0.125, 0.000, 0.500],
        [0.375, 0.000, 0.500],
        [0.625, 0.000, 0.500],
        [0.875, 0.000, 0.500],
        [0.125, 1.000, 0.500],
        [0.375, 1.000, 0.500],
        [0.625, 1.000, 0.500],
        [0.875, 1.000, 0.500],
    ])
    nodew = gwf.disv.ncpl.array * 2 + welcells["nodenumber"][0]
    plocs = [nodew for i in range(pcoord.shape[0])]

    # create particle data
    pa = flopy.modpath.ParticleData(
        plocs,
        structured=False,
        localx=pcoord[:, 0],
        localy=pcoord[:, 1],
        localz=pcoord[:, 2],
        drape=0,
    )

    # create backward particle group
    fpth = mp_namea + ".sloc"
    pga = flopy.modpath.ParticleGroup(particlegroupname="BACKWARD1",
                                      particledata=pa,
                                      filename=fpth)

    facedata = flopy.modpath.FaceDataType(
        drape=0,
        verticaldivisions1=10,
        horizontaldivisions1=10,
        verticaldivisions2=10,
        horizontaldivisions2=10,
        verticaldivisions3=10,
        horizontaldivisions3=10,
        verticaldivisions4=10,
        horizontaldivisions4=10,
        rowdivisions5=0,
        columndivisions5=0,
        rowdivisions6=4,
        columndivisions6=4,
    )
    pb = flopy.modpath.NodeParticleData(subdivisiondata=facedata, nodes=nodew)
    # create forward particle group
    fpth = mp_nameb + ".sloc"
    pgb = flopy.modpath.ParticleGroupNodeTemplate(
        particlegroupname="BACKWARD2", particledata=pb, filename=fpth)

    # create modpath files
    mp = flopy.modpath.Modpath7(modelname=mp_namea,
                                flowmodel=gwf,
                                exe_name="mp7",
                                model_ws=model_ws)
    flopy.modpath.Modpath7Bas(mp, porosity=0.1)
    flopy.modpath.Modpath7Sim(
        mp,
        simulationtype="combined",
        trackingdirection="backward",
        weaksinkoption="pass_through",
        weaksourceoption="pass_through",
        referencetime=0.0,
        stoptimeoption="extend",
        timepointdata=[500, 1000.0],
        particlegroups=pga,
    )

    # write modpath datasets
    mp.write_input()

    # run modpath
    mp.run_model()

    # create modpath files
    mp = flopy.modpath.Modpath7(modelname=mp_nameb,
                                flowmodel=gwf,
                                exe_name="mp7",
                                model_ws=model_ws)
    flopy.modpath.Modpath7Bas(mp, porosity=0.1)
    flopy.modpath.Modpath7Sim(
        mp,
        simulationtype="endpoint",
        trackingdirection="backward",
        weaksinkoption="pass_through",
        weaksourceoption="pass_through",
        referencetime=0.0,
        stoptimeoption="extend",
        particlegroups=pgb,
    )

    # write modpath datasets
    mp.write_input()

    # run modpath
    mp.run_model()
    return
Beispiel #6
0
def test_gridgen():

    # define the base grid and then create a couple levels of nested
    # refinement
    Lx = 10000.
    Ly = 10500.
    nlay = 3
    nrow = 21
    ncol = 20
    delr = Lx / ncol
    delc = Ly / nrow
    top = 400
    botm = [220, 200, np.random.random((nrow, ncol))]

    # create a dummy dis package for gridgen
    ms = flopy.modflow.Modflow()
    dis5 = flopy.modflow.ModflowDis(ms, nlay=nlay, nrow=nrow, ncol=ncol,
                                    delr=delr,
                                    delc=delc, top=top, botm=botm)

    gridgen_ws = cpth
    g = Gridgen(dis5, model_ws=gridgen_ws, exe_name=exe_name)

    rf0shp = os.path.join(gridgen_ws, 'rf0')
    xmin = 7 * delr
    xmax = 12 * delr
    ymin = 8 * delc
    ymax = 13 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 1, range(nlay))

    rf1shp = os.path.join(gridgen_ws, 'rf1')
    xmin = 8 * delr
    xmax = 11 * delr
    ymin = 9 * delc
    ymax = 12 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 2, range(nlay))

    rf2shp = os.path.join(gridgen_ws, 'rf2')
    xmin = 9 * delr
    xmax = 10 * delr
    ymin = 10 * delc
    ymax = 11 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 3, range(nlay))

    # if gridgen executable is available then do the main part of the test
    if run:

        # Use gridgen to build the grid
        g.build()

        # test the different gridprops dictionaries, which contain all the
        # information needed to make the different discretization packages
        gridprops = g.get_gridprops_disv()
        gridprops = g.get_gridprops()
        #gridprops = g.get_gridprops_disu6()

        # test the gridgen point intersection
        points = [(4750., 5250.)]
        cells = g.intersect(points, 'point', 0)
        n = cells['nodenumber'][0]
        msg = ('gridgen point intersect did not identify the correct '
               'cell {} <> {}'.format(n, 308))
        assert n == 308, msg

        # test the gridgen line intersection
        line = [[[(Lx, Ly), (Lx, 0.)]]]
        cells = g.intersect(line, 'line', 0)
        nlist = [n for n in cells['nodenumber']]
        nlist2 = [19, 650, 39, 630, 59, 610, 79, 590, 99, 570, 119, 550, 139,
                  530, 159, 510, 194, 490, 265, 455, 384]
        msg = ('gridgen line intersect did not identify the correct '
               'cells {} <> {}'.format(nlist, nlist2))
        assert nlist == nlist2, msg

        # test getting a modflow-usg disu package
        mu = flopy.modflow.Modflow(version='mfusg', structured=False)
        disu = g.get_disu(mu)

    return
Beispiel #7
0
def test_gridgen():

    # define the base grid and then create a couple levels of nested
    # refinement
    Lx = 10000.
    Ly = 10500.
    nlay = 3
    nrow = 21
    ncol = 20
    delr = Lx / ncol
    delc = Ly / nrow
    top = 400
    botm = [220, 200, np.random.random((nrow, ncol))]

    # create a dummy dis package for gridgen
    ms = flopy.modflow.Modflow()
    dis5 = flopy.modflow.ModflowDis(ms,
                                    nlay=nlay,
                                    nrow=nrow,
                                    ncol=ncol,
                                    delr=delr,
                                    delc=delc,
                                    top=top,
                                    botm=botm)

    gridgen_ws = cpth
    g = Gridgen(dis5, model_ws=gridgen_ws, exe_name=exe_name)

    rf0shp = os.path.join(gridgen_ws, 'rf0')
    xmin = 7 * delr
    xmax = 12 * delr
    ymin = 8 * delc
    ymax = 13 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 1, range(nlay))

    rf1shp = os.path.join(gridgen_ws, 'rf1')
    xmin = 8 * delr
    xmax = 11 * delr
    ymin = 9 * delc
    ymax = 12 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 2, range(nlay))

    rf2shp = os.path.join(gridgen_ws, 'rf2')
    xmin = 9 * delr
    xmax = 10 * delr
    ymin = 10 * delc
    ymax = 11 * delc
    rfpoly = [[[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax),
                (xmin, ymin)]]]
    g.add_refinement_features(rfpoly, 'polygon', 3, range(nlay))

    # if gridgen executable is available then do the main part of the test
    if run:

        # Use gridgen to build the grid
        g.build()

        # test the different gridprops dictionaries, which contain all the
        # information needed to make the different discretization packages
        gridprops = g.get_gridprops_disv()
        gridprops = g.get_gridprops()
        #gridprops = g.get_gridprops_disu6()

        # test the gridgen point intersection
        points = [(4750., 5250.)]
        cells = g.intersect(points, 'point', 0)
        n = cells['nodenumber'][0]
        msg = ('gridgen point intersect did not identify the correct '
               'cell {} <> {}'.format(n, 308))
        assert n == 308, msg

        # test the gridgen line intersection
        line = [[[(Lx, Ly), (Lx, 0.)]]]
        cells = g.intersect(line, 'line', 0)
        nlist = [n for n in cells['nodenumber']]
        nlist2 = [
            19, 650, 39, 630, 59, 610, 79, 590, 99, 570, 119, 550, 139, 530,
            159, 510, 194, 490, 265, 455, 384
        ]
        msg = ('gridgen line intersect did not identify the correct '
               'cells {} <> {}'.format(nlist, nlist2))
        assert nlist == nlist2, msg

        # test getting a modflow-usg disu package
        mu = flopy.modflow.Modflow(version='mfusg', structured=False)
        disu = g.get_disu(mu)

    return
Beispiel #8
0
# ---- Build new grid ----
model_utils.cprint('Building Gridgen model ...')
g.build()
'''
fig = plt.figure(figsize=(15, 15))
ax = fig.add_subplot(1, 1, 1, aspect='equal')
g.plot(ax, linewidth=0.3)
plt.show()
'''

###############################################################################################################################
#                                      Fetch DISV properties & build icpl dictionnary                                         #
###############################################################################################################################
model_utils.cprint('Processing Gridgen intersection ...')
# ---- Fetch DISV properties
gridprops = g.get_gridprops_disv()
# ---- Fetch centroids coordinates
cx = [cell[1] for cell in gridprops['cell2d']]
cy = [cell[2] for cell in gridprops['cell2d']]

# ---- Set top as topo data
# rfilename = os.path.join(sig_dir,'sim', 'dem.tif')
# rio = Raster.load(rfilename)
# gridprops['top'] = rio.resample_to_grid(np.array(cx), np.array(cy), band=rio.bands[0], method="nearest")
gridprops['top'] = top

# ---- Fetch resolution dictionary
res_dic = model_utils.get_res_dic_from_gridgen(g)

# ---- Set lists of intersections for all boundaries package settings
inter_list = ['drain', 'river', 'ghb', 'active']