anypinn.cli.scaffold.inverse_diffusivity.ode

Inverse Diffusivity — PDE problem definition.

GRID_SIZE = 50 module-attribute

create_data_module_csv(hp: PINNHyperparameters) -> InverseDiffusivityDataModule

Source code in src/anypinn/cli/scaffold/inverse_diffusivity/ode.py

def create_data_module_csv(hp: PINNHyperparameters) -> InverseDiffusivityDataModule:
    return InverseDiffusivityDataModule(
        hp=hp,
        grid_size=GRID_SIZE,
        validation=_validation,
    )

create_data_module_synthetic(hp: PINNHyperparameters) -> InverseDiffusivityDataModule

Source code in src/anypinn/cli/scaffold/inverse_diffusivity/ode.py

def create_data_module_synthetic(hp: PINNHyperparameters) -> InverseDiffusivityDataModule:
    return InverseDiffusivityDataModule(
        hp=hp,
        grid_size=GRID_SIZE,
        validation=_validation,
    )

create_problem_forward(hp: PINNHyperparameters) -> Problem

Source code in src/anypinn/cli/scaffold/inverse_diffusivity/ode.py

def create_problem_forward(hp: PINNHyperparameters) -> Problem:
    encode = FourierEncoding(num_frequencies=6)
    field_u = Field(
        config=MLPConfig(
            in_dim=encode.out_dim(2),
            out_dim=1,
            hidden_layers=hp.fields_config.hidden_layers,
            activation=hp.fields_config.activation,
            output_activation=hp.fields_config.output_activation,
            encode=encode,
        )
    )

    fields = FieldsRegistry({U_KEY: field_u})
    params = ParamsRegistry({})

    bcs = [
        DirichletBCConstraint(
            BoundaryCondition(sampler=_left_boundary, value=_zero, n_pts=100),
            field_u,
            log_key="loss/bc_left",
            weight=10.0,
        ),
        DirichletBCConstraint(
            BoundaryCondition(sampler=_right_boundary, value=_zero, n_pts=100),
            field_u,
            log_key="loss/bc_right",
            weight=10.0,
        ),
        DirichletBCConstraint(
            BoundaryCondition(sampler=_initial_condition, value=_ic_value, n_pts=100),
            field_u,
            log_key="loss/ic",
            weight=10.0,
        ),
    ]

    pde = PDEResidualConstraint(
        fields=fields,
        params=params,
        residual_fn=diffusivity_residual_forward,
        log_key="loss/pde_residual",
        weight=1.0,
    )

    return Problem(
        constraints=[pde, *bcs],
        criterion=build_criterion(hp.criterion),
        fields=fields,
        params=params,
    )

create_problem_inverse(hp: PINNHyperparameters) -> Problem

Source code in src/anypinn/cli/scaffold/inverse_diffusivity/ode.py

def create_problem_inverse(hp: PINNHyperparameters) -> Problem:
    encode = FourierEncoding(num_frequencies=6)
    field_u = Field(
        config=MLPConfig(
            in_dim=encode.out_dim(2),
            out_dim=1,
            hidden_layers=hp.fields_config.hidden_layers,
            activation=hp.fields_config.activation,
            output_activation=hp.fields_config.output_activation,
            encode=encode,
        )
    )
    field_d = Field(
        config=MLPConfig(
            in_dim=encode.out_dim(2),
            out_dim=1,
            hidden_layers=hp.fields_config.hidden_layers,
            activation=hp.fields_config.activation,
            output_activation="softplus",
            encode=encode,
        )
    )

    fields = FieldsRegistry({U_KEY: field_u, D_KEY: field_d})
    params = ParamsRegistry({})

    bcs = [
        DirichletBCConstraint(
            BoundaryCondition(sampler=_left_boundary, value=_zero, n_pts=100),
            field_u,
            log_key="loss/bc_left",
            weight=10.0,
        ),
        DirichletBCConstraint(
            BoundaryCondition(sampler=_right_boundary, value=_zero, n_pts=100),
            field_u,
            log_key="loss/bc_right",
            weight=10.0,
        ),
        DirichletBCConstraint(
            BoundaryCondition(sampler=_initial_condition, value=_ic_value, n_pts=100),
            field_u,
            log_key="loss/ic",
            weight=10.0,
        ),
    ]

    pde = PDEResidualConstraint(
        fields=fields,
        params=params,
        residual_fn=diffusivity_residual_inverse,
        log_key="loss/pde_residual",
        weight=1.0,
    )

    data = DataConstraint(
        fields=fields,
        params=params,
        predict_data=predict_data,
        weight=5.0,
    )

    return Problem(
        constraints=[pde, *bcs, data],
        criterion=build_criterion(hp.criterion),
        fields=fields,
        params=params,
    )

diffusivity_residual_forward(x: Tensor, fields: FieldsRegistry, _params: ParamsRegistry) -> Tensor

PDE residual: du/dt - d/dx(D(x) du/dx) = 0 (D(x) known).

Source code in src/anypinn/cli/scaffold/inverse_diffusivity/ode.py

def diffusivity_residual_forward(
    x: Tensor, fields: FieldsRegistry, _params: ParamsRegistry
) -> Tensor:
    """PDE residual: du/dt - d/dx(D(x) du/dx) = 0 (D(x) known)."""
    u = fields[U_KEY](x)
    D = TRUE_D_FN(x[:, 0:1])
    dD_dx = 2 * math.pi * 0.05 * torch.cos(2 * math.pi * x[:, 0:1])
    du_dt = partial(u, x, dim=1, order=1)
    du_dx = partial(u, x, dim=0, order=1)
    d2u_dx2 = partial(u, x, dim=0, order=2)
    return du_dt - (dD_dx * du_dx + D * d2u_dx2)

diffusivity_residual_inverse(x: Tensor, fields: FieldsRegistry, _params: ParamsRegistry) -> Tensor

PDE residual: du/dt - d/dx(D(x) du/dx) = 0 (D(x) learned).

Source code in src/anypinn/cli/scaffold/inverse_diffusivity/ode.py

def diffusivity_residual_inverse(
    x: Tensor, fields: FieldsRegistry, _params: ParamsRegistry
) -> Tensor:
    """PDE residual: du/dt - d/dx(D(x) du/dx) = 0 (D(x) learned)."""
    u = fields[U_KEY](x)
    D = fields[D_KEY](x)
    du_dt = partial(u, x, dim=1, order=1)
    du_dx = partial(u, x, dim=0, order=1)
    d2u_dx2 = partial(u, x, dim=0, order=2)
    dD_dx = partial(D, x, dim=0, order=1)
    return du_dt - (dD_dx * du_dx + D * d2u_dx2)

predict_data(x_data: Tensor, fields: FieldsRegistry, _params: ParamsRegistry) -> Tensor

Source code in src/anypinn/cli/scaffold/inverse_diffusivity/ode.py

def predict_data(x_data: Tensor, fields: FieldsRegistry, _params: ParamsRegistry) -> Tensor:
    return fields[U_KEY](x_data).unsqueeze(1)