# Defining an array of symbolic variables causes error with NeuralPDE.discretize()

**URL:** <https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842>\
**Category:** General Usage\
**Tags:** sciml, symbolics\
**Created:** [July 6, 2022, 3:56pm UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842 "2022-07-06T15:56:14Z")\
**Posts on this page:** 8\
**Page:** 1

<div class="post-metadata">

**Author:** ![hpieper14](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/hpieper14/32/37510_2.png) [@hpieper14](https://discourse.julialang.org/u/hpieper14)\
**Post date:** [July 6, 2022, 3:56pm UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842/1 "2022-07-06T15:56:14Z")

</div>

I am trying to solve a PDE with variables [t, z1, …, zn] using `NeuralPDE.jl`. Here’s my code:

```nohighlight
using Test, Flux, Optim, DiffEqFlux, Optimization
using Random, NeuralPDE, DifferentialEquations
using Statistics, Distributions, LinearAlgebra
import ModelingToolkit: Interval 
import DomainSets: UnitInterval
Random.seed!(100)

order = 3

@parameters t z[1:order]
z = collect(z)
@variables u(..)
Dt = Differential(t)
α = 1.2
β = 1.1

function dW(t, z)
    val = 0 
    for i in 1:size(z)[1]
        val += z[i]*cos((i-1/2)π*t)
    end
    val = √2*val
end
eq = Dt(u(t,z)) ~ α*u(t,z) + β*u(t,z)*dW(t,z)
bcs = [u(0, z) ~ 1.0]

# Space and time domains
domains = Vector{Symbolics.VarDomainPairing}(undef, order + 1)
domains[1] = t ∈ Interval(0.0, 1.0)
for i in 1:order
    domains[i+1] = z[i] ∈ Interval(0.0, 1.0)
end

# number of dimensions
dim = order + 1
chain = Flux.Chain(Dense(dim,16,Flux.σ),Dense(16,16,Flux.σ),Dense(16,1))
# Initial parameters of Neural network
initθ = Float64.(DiffEqFlux.initial_params(chain))

# Discretization
dx = 0.05
discretization = PhysicsInformedNN(chain,GridTraining(dx),init_params =initθ)

@named pde_system = PDESystem(eq,bcs,domains,[t,z],[u(t,z)])
prob = discretize(pde_system,discretization)

```

When I run this, I get the following error:

```julia
ERROR: MethodError: no method matching nameof(::Vector{Num})
Closest candidates are:
  nameof(::Sym) at ~/.julia/packages/SymbolicUtils/vnuIf/src/types.jl:144
  nameof(::ModelingToolkit.AbstractSystem) at ~/.julia/packages/ModelingToolkit/iHLWM/src/systems/abstractsystem.jl:139
  nameof(::DataType) at /Applications/Julia-1.7.app/Contents/Resources/julia/share/julia/base/reflection.jl:223
  ...
Stacktrace:
  [1] _getname(x::Vector{Num}, #unused#::Dict{Any, Any})
    @ Symbolics ~/.julia/packages/Symbolics/sDAUx/src/variable.jl:351
  [2] getname(x::Vector{Num}, val::Dict{Any, Any}) (repeats 2 times)
    @ Symbolics ~/.julia/packages/Symbolics/sDAUx/src/variable.jl:364
  [3] _broadcast_getindex_evalf
    @ ./broadcast.jl:670 [inlined]
  [4] _broadcast_getindex
    @ ./broadcast.jl:643 [inlined]
  [5] getindex
    @ ./broadcast.jl:597 [inlined]
  [6] copyto_nonleaf!(dest::Vector{Symbol}, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Symbolics.getname), Tuple{Base.Broadcast.Extruded{Vector{Any}, Tuple{Bool}, Tuple{Int64}}}}, iter::Base.OneTo{Int64}, state::Int64, count::Int64)
    @ Base.Broadcast ./broadcast.jl:1055
  [7] copy
    @ ./broadcast.jl:907 [inlined]
  [8] materialize
    @ ./broadcast.jl:860 [inlined]
  [9] get_vars(indvars_::Vector{Any}, depvars_::Vector{Num})
    @ NeuralPDE ~/Documents/Julia-fork/NeuralPDE.jl/src/pinns_pde_solve.jl:750
 [10] discretize_inner_functions(pde_system::PDESystem, discretization::PhysicsInformedNN{GridTraining{Float64}, Vector{Float64}, NeuralPDE.Phi{Optimisers.Restructure{Chain{Tuple{Dense{typeof(σ), Matrix{Float32}, Vector{Float32}}, Dense{typeof(σ), Matrix{Float32}, Vector{Float32}}, Dense{typeof(identity), Matrix{Float32}, Vector{Float32}}}}, NamedTuple{(:layers,), Tuple{Tuple{NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}}}}}}, typeof(NeuralPDE.numeric_derivative), Bool, Nothing, NonAdaptiveLoss{Float64}, Nothing, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})
    @ NeuralPDE ~/Documents/Julia-fork/NeuralPDE.jl/src/pinns_pde_solve.jl:1257
 [11] discretize(pde_system::PDESystem, discretization::PhysicsInformedNN{GridTraining{Float64}, Vector{Float64}, NeuralPDE.Phi{Optimisers.Restructure{Chain{Tuple{Dense{typeof(σ), Matrix{Float32}, Vector{Float32}}, Dense{typeof(σ), Matrix{Float32}, Vector{Float32}}, Dense{typeof(identity), Matrix{Float32}, Vector{Float32}}}}, NamedTuple{(:layers,), Tuple{Tuple{NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}}}}}}, typeof(NeuralPDE.numeric_derivative), Bool, Nothing, NonAdaptiveLoss{Float64}, Nothing, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})
    @ NeuralPDE ~/Documents/Julia-fork/NeuralPDE.jl/src/pinns_pde_solve.jl:1512
 [12] top-level scope
    @ ~/Documents/Julia-fork/NeuralPDE.jl/test/NNSDE_wp_tests.jl:56

```

The stack trace tells me that the error is coming from `Symbolics.jl`, but I’m not sure if the issue is with how I am initializing my variables or if something else is going on here.

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [July 6, 2022, 11:30pm UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842/2 "2022-07-06T23:30:12Z")

</div>

> [@hpieper14](#):
>
> `@named pde_system = PDESystem(eq,bcs,domains,[t,z],[u(t,z)])`

`z` is a vector of `Num`s (vector of symbolic values), not a `Num` itself. But the constructor that the example shows is always just an array or list of symbolic values. So you want to do

```julia
@named pde_system = PDESystem(eq,bcs,domains,[t,z...],[u(t,z...)])

```

which is the same as writing out

```julia
@named pde_system = PDESystem(eq,bcs,domains,[t,z1,z2,...,zn],[u(t,z1,z2,...,zn)])

```

---

<div class="post-metadata">

**Author:** ![contradict](https://avatars.discourse-cdn.com/v4/letter/c/ac91a4/32.png) [@contradict](https://discourse.julialang.org/u/contradict)\
**Post date:** [July 7, 2022, 12:12am UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842/3 "2022-07-07T00:12:19Z")

</div>

I suspect you need to splat `z` everywhere you call `u`:

```julia
using Flux, DiffEqFlux
using Random, NeuralPDE, DifferentialEquations
import ModelingToolkit: Interval
import DomainSets: UnitInterval
Random.seed!(100)

order = 3
@parameters z[1:order]
# z = collect(z)
@variables t u(..)
Dt = Differential(t)
α = 1.2
β = 1.1

function dW(t, z)
    val = 0
    for (i, zi) in enumerate(z)
        val += zi*cos((i-1/2)π*t)
    end
    val = √2*val
end

eq = Dt(u(t,z...)) ~ α*u(t,z...) + β*u(t,z...)*dW(t,z)

bcs = [u(0, z...) ~ 1.0]

# Space and time domains
domains = Vector{Symbolics.VarDomainPairing}(undef, order + 1)
domains[1] = t ∈ Interval(0.0, 1.0)
for i in 1:order
    domains[i+1] = z[i] ∈ Interval(0.0, 1.0)
end

# number of dimensions
dim = order + 1
chain = Flux.Chain(Dense(dim,16,Flux.σ),Dense(16,16,Flux.σ),Dense(16,1))
# Initial parameters of Neural network
initθ = Float64.(DiffEqFlux.initial_params(chain))

# Discretization
dx = 0.05
discretization = PhysicsInformedNN(chain,GridTraining(dx),init_params =initθ)

@named pde_system = PDESystem(eq,bcs,domains,[t,z...],[u(t,z...)])
prob = discretize(pde_system,discretization)

```

> **But that still gives an error: No method matching nameof(::Term)**
>
> julia\> prob = discretize(pde\_system,discretization)  
> ERROR: MethodError: no method matching nameof(::Term{Real, Base.ImmutableDict{DataType, Any}})  
> Closest candidates are:  
> nameof(::Sym) at ~/.julia/packages/SymbolicUtils/vnuIf/src/types.jl:144  
> nameof(::ModelingToolkit.AbstractSystem) at ~/.julia/packages/ModelingToolkit/tMgaW/src/systems/abstractsystem.jl:139  
> nameof(::DataType) at /usr/local/stow/julia-1.7.3/share/julia/base/reflection.jl:223  
> …  
> Stacktrace:  
> [1] (::NeuralPDE.var"#40#41")(argument::Term{Real, Base.ImmutableDict{DataType, Any}})  
> @ NeuralPDE ./none:0  
> [2] iterate  
> @ ./generator.jl:47 [inlined]  
> [3] collect\_to!(dest::Vector{Symbol}, itr::Base.Generator{Vector{SymbolicUtils.Symbolic{Real}}, NeuralPDE.var"#40#41"}, offs::Int64, st::Int64)  
> @ Base ./array.jl:782  
> [4] collect\_to\_with\_first!  
> @ ./array.jl:760 [inlined]  
> [5] collect(itr::Base.Generator{Vector{SymbolicUtils.Symbolic{Real}}, NeuralPDE.var"#40#41"})  
> @ Base ./array.jl:734  
> [6] get\_vars(indvars\_::Vector{Num}, depvars\_::Vector{Num})  
> @ NeuralPDE ~/.julia/packages/NeuralPDE/iNhvg/src/symbolic\_utilities.jl:353  
> [7] symbolic\_discretize(pde\_system::PDESystem, discretization::PhysicsInformedNN{GridTraining{Float64}, Vector{Float64}, NeuralPDE.Phi{Optimisers.Restructure{Chain{Tuple{Dense{typeof(σ), Matrix{Float32}, Vector{Float32}}, Dense{typeof(σ), Matrix{Float32}, Vector{Float32}}, Dense{typeof(identity), Matrix{Float32}, Vector{Float32}}}}, NamedTuple{(:layers,), Tuple{Tuple{NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}}}}}, Nothing}, typeof(NeuralPDE.numeric\_derivative), Bool, Nothing, Nothing, Nothing, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})  
> @ NeuralPDE ~/.julia/packages/NeuralPDE/iNhvg/src/discretize.jl:420  
> [8] discretize(pde\_system::PDESystem, discretization::PhysicsInformedNN{GridTraining{Float64}, Vector{Float64}, NeuralPDE.Phi{Optimisers.Restructure{Chain{Tuple{Dense{typeof(σ), Matrix{Float32}, Vector{Float32}}, Dense{typeof(σ), Matrix{Float32}, Vector{Float32}}, Dense{typeof(identity), Matrix{Float32}, Vector{Float32}}}}, NamedTuple{(:layers,), Tuple{Tuple{NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}, NamedTuple{(:weight, :bias, :σ), Tuple{Int64, Int64, Tuple{}}}}}}}, Nothing}, typeof(NeuralPDE.numeric\_derivative), Bool, Nothing, Nothing, Nothing, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}})  
> @ NeuralPDE ~/.julia/packages/NeuralPDE/iNhvg/src/discretize.jl:669  
> [9] top-level scope  
> @ REPL[29]:1  
> [10] top-level scope  
> @ ~/.julia/packages/CUDA/tTK8Y/src/initialization.jl:52

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [July 7, 2022, 8:30am UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842/4 "2022-07-07T08:30:59Z")

</div>

@shashi let’s chat about this one when I get back.

---

<div class="post-metadata">

**Author:** ![hpieper14](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/hpieper14/32/37510_2.png) [@hpieper14](https://discourse.julialang.org/u/hpieper14)\
**Post date:** [July 13, 2022, 9:50pm UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842/5 "2022-07-13T21:50:20Z")

</div>

Is there anything I can do to help with this?

---

<div class="post-metadata">

**Author:** ![shashi](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/shashi/32/1824_2.png) [@shashi](https://discourse.julialang.org/u/shashi)\
**Post date:** [July 14, 2022, 1:58am UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842/6 "2022-07-14T01:58:18Z")

</div>

it requires splatting `z` at the moment… We should eventually support it, but still only when `z` is not collected… Do open an issue about this so that it does not get lost.!

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [July 14, 2022, 7:15am UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842/7 "2022-07-14T07:15:54Z")

</div>

@hpieper14 open an issue on NeuralPDE.jl with this example. I think you’d just have to go step by step through the parser and make it expand `z` internally. Though the `nameof` issue might be solved by @shashi’s recent change?

---

<div class="post-metadata">

**Author:** ![shashi](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/shashi/32/1824_2.png) [@shashi](https://discourse.julialang.org/u/shashi)\
**Post date:** [July 14, 2022, 4:21pm UTC](https://discourse.julialang.org/t/defining-an-array-of-symbolic-variables-causes-error-with-neuralpde-discretize/83842/8 "2022-07-14T16:21:37Z")

</div>

No I think the recent changes are unrelated. It really needs to be handled at the modeling DSL level, not Symbolics level.