I created my PDE and nodes like:
# Define the PDE
class wavePDE (PDE):
name = "AcousticWaveEquation "
def __init__(self, u="u", c="c", S="S", dim=3, time=True, mixed_form=False):
# set params
self.u = u
self.dim = dim
self.time = time
self.mixed_form = mixed_form
# coordinates
x, y, z = Symbol("x"), Symbol("y"), Symbol("z")
# time
t = Symbol("t")
# make input variables
input_variables = {"x": x, "y": y, "z": z, "t": t}
if self.dim == 1:
input_variables.pop("y")
input_variables.pop("z")
elif self.dim == 2:
input_variables.pop("z")
if not self.time:
input_variables.pop("t")
# Scalar function (make u function)
assert type(u) == str, "u needs to be string"
u = Function(u)(*input_variables)
# wave speed coefficient
if type(c) is str:
c = Function(c)(*input_variables)
elif type(c) in [float, int]:
c = Number(c)
# Source Term
if type(S) is str:
S = Function(S)(*input_variables)
elif type(S) in [float, int]:
S = Number(S)
# set equations
self.equations = {}
if not self.mixed_form:
self.equations["wave_PDE"] = (
u.diff(t, 2)
- c**2 * u.diff(x, 2)
- c**2 * u.diff(y, 2)
- c**2 * u.diff(z, 2)
- S
)
elif self.mixed_form:
u_x = Function("u_x")(*input_variables)
u_y = Function("u_y")(*input_variables)
if self.dim == 3:
u_z = Function("u_z")(*input_variables)
else:
u_z = Number(0)
if self.time:
u_t = Function("u_t")(*input_variables)
else:
u_t = Number(0)
self.equations["wave_PDE"] = (
u_t.diff(t)
- c**2 * u_x.diff(x)
- c**2 * u_y.diff(y)
- c**2 * u_z.diff(z)
)
self.equations["compatibility_u_x"] = u.diff(x) - u_x
self.equations["compatibility_u_y"] = u.diff(y) - u_y
self.equations["compatibility_u_z"] = u.diff(z) - u_z
self.equations["compatibility_u_xy"] = u_x.diff(y) - u_y.diff(x)
self.equations["compatibility_u_xz"] = u_x.diff(z) - u_z.diff(x)
self.equations["compatibility_u_yz"] = u_y.diff(z) - u_z.diff(y)
if self.dim == 2:
self.equations.pop("compatibility_u_z")
self.equations.pop("compatibility_u_xz")
self.equations.pop("compatibility_u_yz")
wave_eq = wavePDE(u="u", c="c", S="S", dim=2, time=True)
# define networks
wave_net = instantiate_arch(
input_keys=[Key("x"), Key("y"), Key("t")],
output_keys=[Key("u")],
cfg=cfg.arch.fully_connected,
)
#Finally, Create the nodes
nodes = wave_eq.make_nodes() + [wave_net.make_node("wave_network"),]
# add interior constraint
interior = PointwiseInteriorConstraint(
nodes=nodes,
geometry=geo,
outvar={"wave_PDE": 0 },
batch_size=4096,
bounds={x: (0, L), y: (0, L)},
#lambda_weighting={"wave_PDE": 0.0001},
parameterization=time_range,
)
DefinedDomain.add_constraint(interior, "Interior")
# add open boundary constraint
bc = PointwiseBoundaryConstraint(
nodes=nodes,
geometry=geo,
outvar={"u": 0},
batch_size=1024,
#lambda_weighting={"u": 0.01 * time_length},
parameterization=time_range,
)
DefinedDomain.add_constraint(bc, "BC")
# initial condition
IC = PointwiseInteriorConstraint(
nodes=nodes,
geometry=geo,
outvar={"u": 0},
batch_size=1024,
#lambda_weighting={"u": 1.0},
parameterization={t: 0.0},
)
DefinedDomain.add_constraint(IC, "IC")
But adding my constraints fail with error:
####################################
could not unroll graph!
This is probably because you are asking to compute a value that is not an output of any node
####################################
invar: [x, y, sdf, area, t]
requested var: [wave_PDE]
computable var: [x, y, sdf, area, t, u]
####################################
Nodes in graph:
node: Sympy Node: wave_PDE
evaluate: SympyToTorch
inputs: [S, c]
derivatives: [u__t__t, u__x__x, u__y__y]
outputs: [wave_PDE]
optimize: False
node: Arch Node: wave_network
evaluate: FullyConnectedArch
inputs: [x, y, t]
derivatives: []
outputs: [u]
optimize: True
####################################
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
Cell In [27], line 4
1 # Specifying Constraints (bcs/ics/interior) sampling
2
3 # add interior constraint
----> 4 interior = PointwiseInteriorConstraint(
5 nodes=nodes,
6 geometry=geo,
7 outvar={"wave_PDE": 0 },
8 batch_size=4096,
9 bounds={x: (0, L), y: (0, L)},
10 #lambda_weighting={"wave_PDE": 0.0001},
11 parameterization=time_range,
12 )
13 DefinedDomain.add_constraint(interior, "Interior")
15 # add open boundary constraint
File ~/.conda/envs/modulus_env/lib/python3.8/site-packages/modulus-22.9-py3.8.egg/modulus/domain/constraint/continuous.py:493, in PointwiseInteriorConstraint.__init__(self, nodes, geometry, outvar, batch_size, bounds, criteria, lambda_weighting, parameterization, fixed_dataset, compute_sdf_derivatives, importance_measure, batch_per_epoch, quasirandom, num_workers, loss, shuffle)
486 dataset = ContinuousPointwiseIterableDataset(
487 invar_fn=invar_fn,
488 outvar_fn=outvar_fn,
489 lambda_weighting_fn=lambda_weighting_fn,
490 )
492 # initialize constraint
--> 493 super().__init__(
494 nodes=nodes,
495 dataset=dataset,
496 loss=loss,
497 batch_size=batch_size,
498 shuffle=shuffle,
499 drop_last=True,
500 num_workers=num_workers,
501 )
File ~/.conda/envs/modulus_env/lib/python3.8/site-packages/modulus-22.9-py3.8.egg/modulus/domain/constraint/constraint.py:55, in Constraint.__init__(self, nodes, dataset, loss, batch_size, shuffle, drop_last, num_workers)
44 self.dataloader = iter(
45 Constraint.get_dataloader(
46 dataset=self.dataset,
(...)
51 )
52 )
54 # construct model from nodes
---> 55 self.model = Graph(
56 nodes,
57 Key.convert_list(self.dataset.invar_keys),
58 Key.convert_list(self.dataset.outvar_keys),
59 )
60 self.model.to(self.device)
61 if self.manager.distributed:
62 # https://pytorch.org/docs/master/notes/cuda.html#id5
File ~/.conda/envs/modulus_env/lib/python3.8/site-packages/modulus-22.9-py3.8.egg/modulus/graph.py:94, in Graph.__init__(self, nodes, invar, req_names, diff_nodes, func_arch, func_arch_allow_partial_hessian)
92 if not set(req_names_no_diff).issubset(self.computable_names):
93 _print_graph_unroll_error(nodes, invar, req_names)
---> 94 raise RuntimeError("Failed Unrolling Graph")
96 # compute only necessary nodes for req_names
97 # Walk backwards from the output nodes in the graph and keep adding required inputs
98 # until all inputs are available in invar
99 nodes = copy(nodes)
RuntimeError: Failed Unrolling Graph
Any suggestions on how to fix this?