bte.dvm.solver

Module Contents

Classes

Grid_onDVDis_NU	A grid class that stores the details and solution of the
BGKSolver	Base class for all neural network modules.

Functions

F_pm_2(f, vp, vm, dx, dt[, limiter])
F_plm(f, vp, vm, dx, dt[, limiter])
linear_reconstruction_VanLeer(fL, f, fR)	linear_reconstruction using VanLeer limiter
linear_reconstruction_MinMod(fL, f, fR)	linear_reconstruction using MinMod limiter
linear_reconstruction(fL, f, fR[, limiter])
get_reflecting_bdv(dis, BV, xi, side[, no_linear])	[summary]

Attributes

EPS

bte.dvm.solver.EPS = 1e-08

bte.dvm.solver.F_pm_2(f, vp, vm, dx, dt, limiter=limiter_minmod)

bte.dvm.solver.F_plm(f, vp, vm, dx, dt, limiter=limiter_minmod)

bte.dvm.solver.linear_reconstruction_VanLeer(fL, f, fR)

linear_reconstruction using VanLeer limiter

Parameters:

• fL (torch.Tensor) – left cell

• f (torch.Tensor) – cell

• fR (torch.Tensor) – right cell

Returns:

leftRec, rightRec

Return type:

torch.Tensor

bte.dvm.solver.linear_reconstruction_MinMod(fL, f, fR)

linear_reconstruction using MinMod limiter

Parameters:

• fL (torch.Tensor) – left cell

• f (torch.Tensor) – cell

• fR (torch.Tensor) – right cell

Returns:

leftRec, rightRec

Return type:

torch.Tensor

bte.dvm.solver.linear_reconstruction(fL, f, fR, limiter=limiter_minmod)

bte.dvm.solver.get_reflecting_bdv(dis, BV, xi, side, no_linear=False)

[summary]

Parameters:

• dis (DVDis) – [description]

• BV ([type]) – [description]

• xi ([type]) – [description]

• side ([type]) – side=-1 for left BV, side=1 for right BV

• no_linear (bool, optional) – [description]. Defaults to False.

Raises:

ValueError – [description]

Returns:

[description]

Return type:

[type]

class bte.dvm.solver.Grid_onDVDis_NU(xmin, xmax, nx, vmin, vmax, nv, v_discrete='uni', device='cpu')

Bases: bte.dvm.distribution.DVDis

A grid class that stores the details and solution of the computational grid.

class bte.dvm.solver.BGKSolver(xmin, xmax, nx, vmin, vmax, nv, v_discrete='uni', BC_type='constant', bgk_simple_kn='simple', device='cpu')

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.

property f

set_order(space_order, time_order, time_stiff=False)

set_space_order(order)

set_time_stepper(method)

set time stepper

Parameters:

• method (str) – can be “bgk-RK1”,”bgk-RK2”,”bgk-RK3”,”bgk-RKs1”,”bgk-RKs2”

• "Euler" –

• "IMEX-1" –

• "IMEX-2" –

• "IMEX" –

set_collisioner(collision_type, **args)

set collision type

Parameters:

collision_type (str) – “BGK” or “FFT”

Raises:

ValueError – _description_

set_initial(kn, f0)

set_BC(BC)

set_BC_Value(LV, RV)

padding_periodic(f)

padding_replicate(f)

padding_constant(f)

get_reflecting_bdv(fb, side)

getTau(U)

update(qP, qN)

padding_reflecting_linear(f)

padding_reflecting(f)

padding_evaporation(f)

padding_evaporation2(f)

upwind(fl, fr, direction=0)

_grad_vf_constant(f, dt)

_grad_vf_2(f, dt)

_grad_vf_weno(f, dt)

_grad_vf_plm(f, dt)

step_rk(dt)

step_imex(dt)

solve_to(tmax, max_dt=None)

step_euler(dt)

get_gas_macro()

返回(rho, m, E)

Returns:

(rho, m, E)

Return type:

torch.array

get_hermite_moments(M_order)

get_f()

get_entropy()