def test_LinearADR_Sine():
    logEvent("LinearADR_Sine")
    sol = AnalyticalSolutions.LinearADR_Sine()
    u = [sol.uOfX(x) for x in X]
    assert u[midpoint_x_index] == 0.22471248696198207
    Du = [sol.duOfX(x)[0] for x in X]
    assert Du[midpoint_x_index] == 6.122493544431436
    aflux = [sol.advectiveFluxOfX(x)[0] for x in X]
    assert aflux[midpoint_x_index] == 0.22471248696198207
    dflux = [sol.diffusiveFluxOfX(x)[0] for x in X]
    assert dflux[midpoint_x_index] == -0.061224935444314364
    tflux = [sol.totalFluxOfX(x)[0] for x in X]
    assert tflux[midpoint_x_index] == 0.1634875515176677
    r = [sol.rOfUX(sol.uOfX(x), x) for x in X]
    assert r[midpoint_x_index] == -6.211206478443425
    if save_plots:
        fig = plt.figure()
        plt.title("LinearADR_Sine")
        plt.plot(Xx, u, label='Solution')
        plt.plot(Xx, Du, label='Gradient')
        plt.plot(Xx, aflux, label='Advective Flux')
        plt.plot(Xx, dflux, label='Diffusive Flux')
        plt.plot(Xx, tflux, label='Total Flux')
        plt.plot(Xx, r, label='reaction')
        plt.legend()
        plt.savefig("LinearADR_Sine.png")
def test_NonlinearAD_SteadyState():
    logEvent("NonlinearAD_SteadyState")
    sol = AnalyticalSolutions.NonlinearAD_SteadyState(q=2, r=1)
    y = [sol.uOfX(x) for x in X]
    assert y[midpoint_x_index] == 0.9948469998751492
    if save_plots:
        fig = plt.figure()
        plt.plot(Xx, y, label='Solution,q=2,r=1')
    sol = AnalyticalSolutions.NonlinearAD_SteadyState(q=1, r=2)
    y = [sol.uOfX(x) for x in X]
    assert y[midpoint_x_index] == 0.990588835252627
    if save_plots:
        fig = plt.figure()
        plt.plot(Xx, [sol.uOfX(x) for x in X], label='Solution,q=1,r=2')
        plt.legend()
        plt.title("NonlinearAD_SteadyState")
        plt.savefig("NonlinearAD_SteadyState.png")
def test_NonlinearADR_Decay_DiracIC():
    logEvent("NonlinearADR_Decay_DiracIC")
    sol = AnalyticalSolutions.NonlinearADR_Decay_DiracIC()
    up25 = [sol.uOfXT(x, T=0.25) for x in X]
    assert up25[midpoint_x_index] == 0.0058003017280384575
    up75 = [sol.uOfXT(x, T=0.75) for x in X]
    assert up75[midpoint_x_index] == 1.3623941337338921e-08
    Dup25 = [sol.duOfXT(x, T=0.25)[0] for x in X]
    assert Dup25[midpoint_x_index] == -0.248169222231705570
    Dup75 = [sol.duOfXT(x, T=0.75)[0] for x in X]
    assert Dup75[midpoint_x_index] == -6.484340816869727e-07
    afluxp25 = [sol.advectiveFluxOfXT(x, T=0.25)[0] for x in X]
    assert afluxp25[midpoint_x_index] == 0.0058003017280384575
    afluxp75 = [sol.advectiveFluxOfXT(x, T=0.75)[0] for x in X]
    assert afluxp75[midpoint_x_index] == 1.3623941337338921e-08
    dfluxp25 = [sol.diffusiveFluxOfXT(x, T=0.25)[0] for x in X]
    assert dfluxp25[midpoint_x_index] == 0.0024816922223170556
    dfluxp75 = [sol.diffusiveFluxOfXT(x, T=0.75)[0] for x in X]
    assert dfluxp75[midpoint_x_index] == 6.484340816869727e-09
    tfluxp25 = [sol.totalFluxOfXT(x, T=0.25)[0] for x in X]
    assert tfluxp25[midpoint_x_index] == 0.008281993950355513
    tfluxp75 = [sol.totalFluxOfXT(x, T=0.75)[0] for x in X]
    assert tfluxp75[midpoint_x_index] == 2.010828215420865e-08
    if save_plots:
        fig = plt.figure()
        plt.plot(Xx,
                 up25,
                 label='Solution,t=0.25')
        plt.plot(Xx,
                 up75,
                 label='Solution,t=0.75')
        plt.plot(Xx,
                 Dup25,
                 label='Gradient,t=0.25')
        plt.plot(Xx,
                 Dup75,
                 label='Gradient,t=0.75')
        plt.plot(Xx,
                 afluxp25,
                 label='Advective Flux,t=0.25')
        plt.plot(Xx,
                 afluxp75,
                 label='Advective Flux,t=0.75')
        plt.plot(Xx,
                 dfluxp25,
                 label='Diffusive Flux,t=0.25')
        plt.plot(Xx,
                 dfluxp75,
                 label='Diffusive Flux,t=0.75')
        plt.plot(Xx,
                 tfluxp25,
                 label='Total Flux,t=0.25')
        plt.plot(Xx,
                 tfluxp75,
                 label='Total Flux,t=0.75')
        plt.legend()
        plt.title("NonlinearADR_Decay_DiracIC.png")
        plt.savefig("NonlinearADR_Decay_DiracIC.png")
def test_LinearADR_Decay_DiracIC():
    logEvent("LinearADR_Decay_DiracIC")
    sol = AnalyticalSolutions.LinearADR_Decay_DiracIC()
    up25 = [sol.uOfXT(x, T=0.25) for x in X]
    assert up25[midpoint_x_index] == 0.0045216528018377404
    up75 = [sol.uOfXT(x, T=0.75) for x in X]
    assert up75[midpoint_x_index] == 6.435494248102993e-09
    Dup25 = [sol.duOfXT(x, T=0.25)[0] for x in X]
    assert Dup25[midpoint_x_index] == -0.19346149763373902
    Dup75 = [sol.duOfXT(x, T=0.75)[0] for x in X]
    assert Dup75[midpoint_x_index] == -3.062985739327577e-07
    afluxp25 = [sol.advectiveFluxOfXT(x, T=0.25)[0] for x in X]
    assert afluxp25[midpoint_x_index] == 0.0045216528018377404
    afluxp75 = [sol.advectiveFluxOfXT(x, T=0.75)[0] for x in X]
    assert afluxp75[midpoint_x_index] == 6.435494248102993e-09
    dfluxp25 = [sol.diffusiveFluxOfXT(x, T=0.25)[0] for x in X]
    assert dfluxp25[midpoint_x_index] == 0.0019346149763373901
    dfluxp75 = [sol.diffusiveFluxOfXT(x, T=0.75)[0] for x in X]
    assert dfluxp75[midpoint_x_index] == 3.062985739327577e-09
    tfluxp25 = [sol.totalFluxOfXT(x, T=0.25)[0] for x in X]
    assert tfluxp25[midpoint_x_index] == 0.00645626777817513
    tfluxp75 = [sol.totalFluxOfXT(x, T=0.75)[0] for x in X]
    assert tfluxp75[midpoint_x_index] == 9.498479987430571e-09
    if save_plots:
        fig = plt.figure()
        plt.plot(Xx,
                 up25,
                 label='Solution,t=0.25')
        plt.plot(Xx,
                 up75,
                 label='Solution,t=0.75')
        plt.plot(Xx,
                 Dup25,
                 label='Gradient,t=0.25')
        plt.plot(Xx,
                 Dup75,
                 label='Gradient,t=0.75')
        plt.plot(Xx,
                 afluxp25,
                 label='Advective Flux,t=0.25')
        plt.plot(Xx,
                 afluxp75,
                 label='Advective Flux,t=0.75')
        plt.plot(Xx,
                 dfluxp25,
                 label='Diffusive Flux,t=0.25')
        plt.plot(Xx,
                 dfluxp75,
                 label='Diffusive Flux,t=0.75')
        plt.plot(Xx,
                 tfluxp25,
                 label='Total Flux,t=0.25')
        plt.plot(Xx,
                 tfluxp75,
                 label='Total Flux,t=0.75')
        plt.legend()
        plt.title("LinearADR_Decay_DiracIC.png")
        plt.savefig("LinearADR_Decay_DiracIC.png")
def test_LinearAD_DiracIC():
    logEvent("LinearAD_DiracIC")
    sol = AnalyticalSolutions.LinearAD_DiracIC()
    up25 = [sol.uOfXT(x, T=0.25) for x in X]
    assert up25[midpoint_x_index] == 0.005805917122996999
    up75 = [sol.uOfXT(x, T=0.75) for x in X]
    assert up75[midpoint_x_index] == 1.362394143014481e-08
    Dup25 = [sol.duOfXT(x, T=0.25)[0] for x in X]
    assert Dup25[midpoint_x_index] == -0.24840948011219627
    Dup75 = [sol.duOfXT(x, T=0.75)[0] for x in X]
    assert Dup75[midpoint_x_index] == -6.484340861040867e-07
    afluxp25 = [sol.advectiveFluxOfXT(x, T=0.25)[0] for x in X]
    assert afluxp25[midpoint_x_index] == 0.005805917122996999
    afluxp75 = [sol.advectiveFluxOfXT(x, T=0.75)[0] for x in X]
    assert afluxp75[midpoint_x_index] == 1.362394143014481e-08
    dfluxp25 = [sol.diffusiveFluxOfXT(x, T=0.25)[0] for x in X]
    assert dfluxp25[midpoint_x_index] == 0.0024840948011219627
    dfluxp75 = [sol.diffusiveFluxOfXT(x, T=0.75)[0] for x in X]
    assert dfluxp75[midpoint_x_index] == 6.484340861040867e-09
    tfluxp25 = [sol.totalFluxOfXT(x, T=0.25)[0] for x in X]
    assert tfluxp25[midpoint_x_index] == 0.008290011924118962
    tfluxp75 = [sol.totalFluxOfXT(x, T=0.75)[0] for x in X]
    assert tfluxp75[midpoint_x_index] == 2.0108282291185675e-08
    if save_plots:
        fig = plt.figure()
        plt.plot(Xx,
                 up25,
                 label='Solution,t=0.25')
        plt.plot(Xx,
                 up75,
                 label='Solution,t=0.75')
        plt.plot(Xx,
                 Dup25,
                 label='Gradient,t=0.25')
        plt.plot(Xx,
                 Dup75,
                 label='Gradient,t=0.75')
        plt.plot(Xx,
                 afluxp25,
                 label='Advective Flux,t=0.25')
        plt.plot(Xx,
                 afluxp75,
                 label='Advective Flux,t=0.75')
        plt.plot(Xx,
                 dfluxp25,
                 label='Diffusive Flux,t=0.25')
        plt.plot(Xx,
                 dfluxp75,
                 label='Diffusive Flux,t=0.75')
        plt.plot(Xx,
                 tfluxp25,
                 label='Total Flux,t=0.25')
        plt.plot(Xx,
                 tfluxp75,
                 label='Total Flux,t=0.75')
        plt.legend()
        plt.title("LinearAD_DiracIC.png")
        plt.savefig("LinearAD_DiracIC.png")
def test_LinearAD_SteadyState():
    logEvent("AD_SteadyState")
    sol = AnalyticalSolutions.LinearAD_SteadyState()
    y = [sol.uOfX(x) for x in X]
    assert y[midpoint_x_index] == 0.9882908500750013
    if save_plots:
        fig = plt.figure()
        plt.plot(Xx, y, label='Solution,q=1,r=1')
        plt.legend()
        plt.title("LinearAD_SteadyStage")
        plt.savefig("LinearAD_SteadyState.png")
Beispiel #7
0
                return np.array([0.0, 0.0, round(x[2], 5)])
            elif (x[1] < eps) or (x[1] > p.L[1] - eps):  #on front or back
                return np.array([round(x[0], 5), 0.0, round(x[2], 5)])
            elif (x[0] < eps) or (
                    x[0] > p.L[0] - eps):  #on inflow or outflow (left/right)
                return np.array([0.0, round(x[1], 5), round(x[2], 5)])

    p.periodicDirichletConditions = {
        0: getPDBC,
        1: getPDBC,
        2: getPDBC,
        3: getPDBC
    }

pSol2 = AnalyticalSolutions.PlanePoiseuilleFlow_p(plateSeperation=h,
                                                  mu=mu,
                                                  grad_p=-G)
uSol2 = AnalyticalSolutions.PlanePoiseuilleFlow_u(plateSeperation=h,
                                                  mu=mu,
                                                  grad_p=-G)
vSol2 = AnalyticalSolutions.PlanePoiseuilleFlow_v(plateSeperation=h,
                                                  mu=mu,
                                                  grad_p=-G)


class pRot(AnalyticalSolutions.SteadyState):
    def __init__(self):
        pass

    def uOfX(self, x):
        if p.nd == 3:
Beispiel #8
0
        self.val = val
        self.ztop = ztop
        self.zbot = zbot
        self.delta_z = delta_z

    def uOfX(self, x):
        fact = exp(-(x[2] - self.zbot) * (self.ztop - x[2]) / self.delta_z)
        return self.val * (1.0 - fact)


if use_PlanePoiseuille:
    uProfile = AnalyticalSolutions.PlanePoiseuilleFlow_u2(
        plane_theta=0.0,
        plane_phi=0.0,
        v_theta=0.0,
        v_phi=math.pi / 2.0,
        v_norm=0.0,
        mu=mu_0,
        grad_p=grad_p,
        L=[1.0, 1.0, upstream_height])

else:
    uProfile = u_flat(val=inflow)


def velRamp(t):
    if t < residence_time:
        return 1.0 - exp(-25.0 * t / residence_time)
    else:
        return 1.0