bte.grad.GradEquationHybrid#

Module Contents#

Classes#

Equation_HermiteBased

Base class for all neural network modules.

Functions#

MaxRootOfHermitePolynomial(N)

simpson(l, m, r)

upwind(fl, fr)

linear_reconstruction(dis, disL, disR[, limiter])

Attributes#

Tensor

bte.grad.GradEquationHybrid.Tensor[source]#
bte.grad.GradEquationHybrid.MaxRootOfHermitePolynomial(N)[source]#
Parameters:

N (int) –

Return type:

float

bte.grad.GradEquationHybrid.simpson(l, m, r)[source]#
bte.grad.GradEquationHybrid.upwind(fl, fr)[source]#
Parameters:
bte.grad.GradEquationHybrid.linear_reconstruction(dis, disL, disR, limiter=limiter_mc)[source]#
Parameters:
class bte.grad.GradEquationHybrid.Equation_HermiteBased(M=5, bdc='circular')[source]#

Bases: torch.nn.Module

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing to nest them in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will have their parameters converted too when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:

training (bool) – Boolean represents whether this module is in training or evaluation mode.

__str__()[source]#

Return str(self).

Return type:

str

set_order(space_order, time_order)[source]#
set_space_order(order)[source]#
set_time_order(order)[source]#
set_initial(kn, f0, dx)[source]#
Parameters:
Grad_Vec(dis, Kn=None)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

Grad_Vec_LLF(dis, Kn=None)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

Grad_Closure(dis, Kn=None)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

NRxx_Closure(dis, Kn)[source]#
Parameters:
Return type:

Tensor

collision_BGK(dis, dt, Kn)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

get_tstep_cell(dis)[source]#

因为一般是在碰撞后求解下一步的时间步长，所以直接读取， 若非如此，需要 _,c,theta=get_pcs(dis)

Parameters:

dis (bte.grad.distribution.HermiteDis) –

get_tstep(dislist, dx)[source]#
Parameters:

dislist (bte.grad.distribution.HermiteDis) –

LLF_helper(disL, disR, fluxL, fluxR, lam)[source]#
Parameters:
HLL_helper(disL, disR, fluxL, fluxR, lambda_L, lambda_R)[source]#
Parameters:
Return type:

bte.grad.distribution.HermiteDis

flux_helper(disL, disR, fluxL, fluxR, Kn, disLO, disRO, lam=0)[source]#
Parameters:
Return type:

bte.grad.distribution.HermiteDis

get_flux_hme_helper(disL, disR)[source]#
Parameters:
get_flux_hme(dis, dx, Kn)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

padding_periodic_dis(f)[source]#
Parameters:

f (bte.grad.distribution.HermiteDis) –

padding_replicate_dis(f)[source]#
Parameters:

f (bte.grad.distribution.HermiteDis) –

padding_constant_dis(f)[source]#
Parameters:

f (bte.grad.distribution.HermiteDis) –

padding_reflect_dis(f)[source]#
Parameters:

f (bte.grad.distribution.HermiteDis) –

padding_linear_dis(f)[source]#
Parameters:

f (bte.grad.distribution.HermiteDis) –

padding_periodic_single(f)[source]#
Parameters:

f (bte.utils.limiter.torch.Tensor) –

padding_replicate_single(f)[source]#
Parameters:

f (bte.utils.limiter.torch.Tensor) –

padding_linear_single(f)[source]#
Parameters:

f (bte.utils.limiter.torch.Tensor) –

padding_reflect_single(f)[source]#
Parameters:

f (bte.utils.limiter.torch.Tensor) –

padding_reflect_single_u(f)[source]#
Parameters:

f (bte.utils.limiter.torch.Tensor) –

padding_constant_single(f)[source]#
Parameters:

f (bte.utils.limiter.torch.Tensor) –

padding_dis(f)[source]#
Parameters:

f (bte.utils.limiter.torch.Tensor) –

Reconstruction_constant(dis)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

Reconstruction_linear(dis)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

abstract Reconstruction_WENO(disM)[source]#
Parameters:

disM (bte.grad.distribution.HermiteDis) –

maxwellian_bdc_fix0(disLP_R, disMP_L, disMP_R, disRP_L, disLO, disRO)[source]#
maxwellian_bdc_fix1(disLP_R, disMP_L, disMP_R, disRP_L, disLO, disRO)[source]#
maxwellian_bdc_fix2(disLP_R, disMP_L, disMP_R, disRP_L, disLO, disRO)[source]#
get_convection_flux(dis, dx, Kn)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

get_flux(dis, dx, Kn)[source]#
Euler(dis, dt, dx, Kn)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

Heun(dis, dt, dx, Kn)[source]#
apply_flux(dis, flux)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

forward(dis, T, dx, Kn, verbose=False)[source]#
Parameters:

dis (bte.grad.distribution.HermiteDis) –

solve_to(T, verbose=False)[source]#
run(dis, T, dx, Kn=None, verbose=False)[source]#
set_BC_Value(LV, RV)[source]#