Python controller.LBSimulationController类代码示例

    def test_timeseries(self):
        settings = {
            'debug_single_process': True,
            'quiet': True,
            'lat_nx': 64,
            'lat_ny': 32,
            'max_iters': 1,
            'check_invalid_results_host': False,
            'check_invalid_results_gpu': False,
            'every': 1,
        }

        x1 = np.arange(0, 20 * 8, 8)
        x2 = np.arange(0, 60 * 1.61, 1.61)
        x3 = np.arange(0, 20 * 4, 4)

        # This one test time-wrapping and a non-integer step size.
        cc = np.hstack([cos_timeseries, cos_timeseries, cos_timeseries])

        f1 = interp1d(x1, sin_timeseries, kind='linear')
        f2 = interp1d(x2, cc, kind='linear')
        f3 = interp1d(x3, 2.0 * sin_timeseries, kind='linear')

        ctrl = LBSimulationController(TestSim, default_config=settings)
        ctrl.run(ignore_cmdline=True)
        runner = ctrl.master.runner
        sim = ctrl.master.sim

        while sim.iteration < 60:
            runner.step(True)
            runner._fields_to_host(True)
            self.assertAlmostEqual(sim.rho[0,5], f1(sim.iteration - 1), places=6)
            self.assertAlmostEqual(sim.rho[0,6], f2(sim.iteration - 1), places=6)
            self.assertAlmostEqual(sim.rho[0,7], f3(sim.iteration - 1), places=6)

def run_test(name):
    basepath = os.path.join("results", name)
    if not os.path.exists(basepath):
        os.makedirs(basepath)

    ctrl = LBSimulationController(TestLDCSim, TestLDCGeometry)
    ctrl.run()
    horiz = np.loadtxt("ldc_golden/re400_horiz", skiprows=1)
    vert = np.loadtxt("ldc_golden/re400_vert", skiprows=1)

    plt.plot(2 * (horiz[:, 0] - 0.5), -2 * (horiz[:, 1] - 0.5), label="Sheu, Tsai paper")
    plt.plot(2 * (vert[:, 0] - 0.5), -2 * (vert[:, 1] - 0.5), label="Sheu, Tsai paper")
    save_output(basepath)
    plt.legend(loc="lower right")
    plt.gca().yaxis.grid(True)
    plt.gca().xaxis.grid(True)
    plt.gca().xaxis.grid(True, which="minor")
    plt.gca().yaxis.grid(True, which="minor")

    plt.title("Lid Driven Cavity, Re = 400")
    print os.path.join(basepath, "re400.pdf")
    plt.savefig(os.path.join(basepath, "re400.pdf"), format="pdf")

    plt.clf()
    plt.cla()
    plt.show()
    shutil.rmtree(tmpdir)

def run_test(name, re, max_iters, i):
    print 'Testing Re = %s' % re

    basepath = os.path.join('results', name, 're%s' % re)
    if not os.path.exists(basepath):
        os.makedirs(basepath)

    ctrl = LBSimulationController(TestLDCSim,
                                  default_config={'re': re, 'max_iters': max_iters})
    ctrl.run(ignore_cmdline=True)
    horiz = np.loadtxt('ldc_golden/vx2d', skiprows=4)
    vert = np.loadtxt('ldc_golden/vy2d', skiprows=4)

    plt.plot(horiz[:, 0] * 2 - 1, horiz[:, i], '.', label='Paper')
    plt.plot(vert[:, i], 2 * (vert[:, 0] - 0.5), '.', label='Paper')
    save_output(basepath, max_iters)
    plt.legend(loc='lower right')
    plt.gca().yaxis.grid(True)
    plt.gca().xaxis.grid(True)
    plt.gca().xaxis.grid(True, which='minor')
    plt.gca().yaxis.grid(True, which='minor')

    plt.title('2D Lid Driven Cavity, Re = %s' % re)
    print os.path.join(basepath, 'results.pdf')
    plt.savefig(os.path.join(basepath, 'results.pdf'), format='pdf')

    plt.clf()
    plt.cla()
    plt.show()

    def test_x_face_propagation(self):
        global tmpdir
        ctrl = LBSimulationController(SingleBlockPeriodicSimulationTest,
                SingleBlockGeoTest)
        ctrl.run(ignore_cmdline=True)

        output = os.path.join(tmpdir, 'per_single_out')
        b0 = np.load(io.dists_filename(output, 1, 0, 1))
        ae = np.testing.assert_equal

        ae(b0[vi(-1, 0, 0), 32, 32, 64], np.float32(0.11))
        ae(b0[vi(-1, 1, 0), 32, 33, 64], np.float32(0.12))
        ae(b0[vi(-1, -1, 0), 32, 31, 64], np.float32(0.13))
        ae(b0[vi(-1, 0, 1), 33, 32, 64], np.float32(0.14))
        ae(b0[vi(-1, 0, -1), 31, 32, 64], np.float32(0.15))

        ae(b0[vi(0, 1, 0), 33, 1, 31], np.float32(0.41))
        ae(b0[vi(0, 0, 1), 1, 35, 31], np.float32(0.42))

        ae(b0[vi(-1, 0, 0), 1, 1, 64], np.float32(0.21))
        ae(b0[vi(0, -1, 0), 1, 62, 1], np.float32(0.22))
        ae(b0[vi(0, 0, -1), 66, 1, 1], np.float32(0.23))

        ae(b0[vi(-1, -1, 0), 1, 62, 64], np.float32(0.24))
        ae(b0[vi(0, -1, -1), 66, 62, 1], np.float32(0.25))
        ae(b0[vi(-1, 0, -1), 66, 1, 64], np.float32(0.26))

        ae(b0[vi(-1, 0, 0), 32, 1, 64], np.float32(0.31))
        ae(b0[vi(-1, -1, 0), 32, 1, 64], np.float32(0.32))

 def test_horiz_2blocks(self):
     global blocks, output
     output = os.path.join(tmpdir, 'horiz_2block')
     blocks = 2
     ctrl = LBSimulationController(SimulationTest, SphereGeometry)
     ctrl.run(ignore_cmdline=True)
     util.verify_fields(self.ref, output, self.digits, MAX_ITERS)

    def test_3d(self):
        s = settings
        s.update({
            'lat_nx': NX,
            'lat_ny': NY,
            'lat_nz': NZ})

        TestSim.subdomain = TestSubdomain3D
        TestSim.subdomain_runner = TestSubdomainRunner3D

        ctrl = LBSimulationController(TestSim, default_config=s)
        ctrl.run(ignore_cmdline=True)

        sim = ctrl.master.sim
        # reduction over Z, Y
        np.testing.assert_array_almost_equal(
            ctrl.master.runner.ret_x,
            np.sum(np.sum(sim.data, axis=0), axis=0))

        # reduction over Z, X
        np.testing.assert_array_almost_equal(
            ctrl.master.runner.ret_y,
            np.sum(np.sum(sim.data, axis=0), axis=1))

        # reduction over Y, X
        np.testing.assert_array_almost_equal(
            ctrl.master.runner.ret_z,
            np.sum(np.sum(sim.data, axis=1), axis=1))

    def test_vert_spread(self):
        def ic(self, runner):
            dbuf = runner._debug_get_dist()
            dbuf[:] = 0.0

            if runner._spec.id == 0:
                dbuf[vi(-1, 1), 128, 64] = 0.11
                dbuf[vi(0, 1), 128, 64] = 0.12
                dbuf[vi(1, 1), 128, 64] = 0.13

            runner._debug_set_dist(dbuf)

        VertTest = type("VertTest", (AASimulationTest,), {"initial_conditions": ic})
        ctrl = LBSimulationController(VertTest, Vertical2BlockGeo)
        ctrl.run(ignore_cmdline=True)

        output = os.path.join(tmpdir, "test_out")
        b0 = np.load(io.dists_filename(output, 1, 0, 1))["arr_0"]
        b1 = np.load(io.dists_filename(output, 1, 1, 1))["arr_0"]
        ae = np.testing.assert_equal

        # No propagation in the first step, but the distributions are stored
        # in opposite slots.
        ae(b1[vi(1, -1), 0, 64], np.float32(0.11))
        ae(b1[vi(0, -1), 0, 64], np.float32(0.12))
        ae(b1[vi(-1, -1), 0, 64], np.float32(0.13))

def run_test(name, re, max_iters, i):
    print("Testing Re = %s" % re)

    basepath = os.path.join("results", name, "re%s" % re)
    if not os.path.exists(basepath):
        os.makedirs(basepath)

    ctrl = LBSimulationController(TestLDCSim, default_config={"re": re, "max_iters": max_iters})
    ctrl.run(ignore_cmdline=True)
    horiz = np.loadtxt("ldc_golden/vx2d", skiprows=4)
    vert = np.loadtxt("ldc_golden/vy2d", skiprows=4)

    plt.plot(horiz[:, 0] * 2 - 1, horiz[:, i], ".", label="Paper")
    plt.plot(vert[:, i], 2 * (vert[:, 0] - 0.5), ".", label="Paper")
    save_output(basepath, max_iters)
    plt.legend(loc="lower right")
    plt.gca().yaxis.grid(True)
    plt.gca().xaxis.grid(True)
    plt.gca().xaxis.grid(True, which="minor")
    plt.gca().yaxis.grid(True, which="minor")

    plt.title("2D Lid Driven Cavity, Re = %s" % re)
    print(os.path.join(basepath, "results.pdf"))
    plt.savefig(os.path.join(basepath, "results.pdf"), format="pdf")

    plt.clf()
    plt.cla()
    plt.show()

    def test_horiz_spread(self):
        def ic(self, runner):
            dbuf = runner._debug_get_dist()
            dbuf[:] = 0.0

            if runner._spec.id == 0:
                dbuf[vi(1, 0), 64, 128] = 0.11
                dbuf[vi(1, 1), 64, 128] = 0.12
                dbuf[vi(1, -1), 64, 128] = 0.13

            runner._debug_set_dist(dbuf)

        HorizTest = type('HorizTest', (AASimulationTest,),
                {'initial_conditions': ic})
        ctrl = LBSimulationController(HorizTest, DoubleBlockGeometryTest)
        ctrl.run(ignore_cmdline=True)

        output = os.path.join(tmpdir, 'test_out')
        b0 = np.load(io.dists_filename(output, 1, 0, 1))['arr_0']
        b1 = np.load(io.dists_filename(output, 1, 1, 1))['arr_0']
        ae = np.testing.assert_equal

        # No propagation in the first step, but the distributions are stored
        # in opposite slots.
        ae(b1[vi(-1, 0), 64, 0], np.float32(0.11))
        ae(b1[vi(-1, -1), 64, 0], np.float32(0.12))
        ae(b1[vi(-1, 1), 64, 0], np.float32(0.13))

    def test_3d(self):
        settings = {
            'debug_single_process': True,
            'quiet': True,
            'check_invalid_results_gpu': False,
            'check_invalid_results_host': False,
            'max_iters': 1,
            'lat_nx': NX,
            'lat_ny': NY,
            'lat_nz': NZ}

        ctrl = LBSimulationController(TestSim, default_config=settings)
        ctrl.run(ignore_cmdline=True)
        sim = ctrl.master.sim

        vort = util.vorticity(sim.v)
        vort_sq = vort[0]**2 + vort[1]**2 + vort[2]**2

        # Convert the velocity field to double precision.
        dbl_v = [x.astype(np.float64) for x in sim.v]

        self.assertAlmostEqual(util.kinetic_energy(dbl_v), sim.kinetic_energy)
        self.assertAlmostEqual(util.enstrophy(dbl_v, dx=1.0), sim.enstrophy)

        np.testing.assert_array_almost_equal(sim.v_sq, sim.vx**2 + sim.vy**2 + sim.vz**2)
        np.testing.assert_array_almost_equal(sim.vort_sq, vort_sq)

    def test_corner_global_periodic(self):
        global tmpdir, periodic_y
        periodic_y = True

        def ic(self, runner):
            dbuf = runner._debug_get_dist()
            dbuf[:] = 0.0
            dbuf[vi(1, 1), 256, 256] = 0.11
            dbuf[vi(-1, -1), 1, 1] = 0.12
            dbuf[vi(1, -1), 1, 256] = 0.13
            dbuf[vi(-1, 1), 256, 1] = 0.14
            runner._debug_set_dist(dbuf)
            runner._debug_set_dist(dbuf, False)

        CornerTest = type("CornerTest", (SimulationTest,), {"initial_conditions": ic})
        ctrl = LBSimulationController(CornerTest)
        ctrl.run(ignore_cmdline=True)

        output = os.path.join(tmpdir, "test_out")
        b0 = np.load(io.dists_filename(output, 1, 0, 1))["arr_0"]
        ae = np.testing.assert_equal

        ae(b0[vi(1, 1), 1, 1], np.float32(0.11))
        ae(b0[vi(-1, -1), 256, 256], np.float32(0.12))
        ae(b0[vi(1, -1), 256, 1], np.float32(0.13))
        ae(b0[vi(-1, 1), 1, 256], np.float32(0.14))

def run_test(name, i):
    global RE
    RE = reynolds[i]
    global MAX_ITERS
    MAX_ITERS = max_iters[i]
    basepath = os.path.join('results', name, 're%s' % RE)
    if not os.path.exists(basepath):
        os.makedirs(basepath)

    ctrl = LBSimulationController(TestLDCSim, TestLDCGeometry)
    ctrl.run()
    horiz = np.loadtxt('ldc_golden/vx2d', skiprows=4)
    vert = np.loadtxt('ldc_golden/vy2d', skiprows=4)

    plt.plot(horiz[:, 0] * 2 - 1, horiz[:, i+1], label='Paper')
    plt.plot(vert[:, i+1], 2 * (vert[:, 0] - 0.5), label='Paper')
    save_output(basepath)
    plt.legend(loc='lower right')
    plt.gca().yaxis.grid(True)
    plt.gca().xaxis.grid(True)
    plt.gca().xaxis.grid(True, which='minor')
    plt.gca().yaxis.grid(True, which='minor')

    plt.title('Lid Driven Cavity, Re = %s' % RE)
    print os.path.join(basepath, 'results.pdf')
    plt.savefig(os.path.join(basepath, 'results.pdf'), format='pdf')

    plt.clf()
    plt.cla()
    plt.show()

def run_test(name):
    basepath = os.path.join('results', name)
    if not os.path.exists(basepath):
        os.makedirs(basepath)

    ctrl = LBSimulationController(TestLDCSim)
    ctrl.run(ignore_cmdline=True)
    horiz = np.loadtxt('ldc_golden/re400_horiz', skiprows=1)
    vert = np.loadtxt('ldc_golden/re400_vert', skiprows=1)

    plt.plot(2 * (horiz[:,0] - 0.5), -2 * (horiz[:,1] - 0.5), '.', label='Sheu, Tsai paper')
    plt.plot(2 * (vert[:,0] - 0.5), -2 * (vert[:,1] - 0.5), '.', label='Sheu, Tsai paper')
    save_output(basepath, MAX_ITERS)
    plt.legend(loc='lower right')
    plt.gca().yaxis.grid(True)
    plt.gca().xaxis.grid(True)
    plt.gca().xaxis.grid(True, which='minor')
    plt.gca().yaxis.grid(True, which='minor')

    plt.title('Lid Driven Cavity, Re = 400')
    print os.path.join(basepath, 're400.pdf' )
    plt.savefig(os.path.join(basepath, 're400.pdf' ), format='pdf')

    plt.clf()
    plt.cla()
    plt.show()
    shutil.rmtree(tmpdir)

 def test_sizes(sizes, geo_cls):
     for w, h, d in sizes:
         print 'Testing {0} x {1} x {2}...'.format(w, h, d)
         settings.update({'lat_nx': int(w), 'lat_ny': int(h), 'lat_nz': int(d)})
         ctrl = LBSimulationController(LDCSim, geo_cls, settings)
         timing_infos, blocks = ctrl.run()
         summary.append(util.summarize(timing_infos, blocks))
         timings.append(timing_infos)

 def setUpClass(cls):
     global blocks, output
     output = os.path.join(tmpdir, 'href')
     blocks = 1
     ctrl = LBSimulationController(SimulationTest, SphereGeometry)
     ctrl.run(ignore_cmdline=True)
     cls.digits = io.filename_iter_digits(MAX_ITERS)
     cls.ref = np.load(io.filename(output, cls.digits, 0, MAX_ITERS))