Solving 3d Transient heat equation for arc welding

[Jagadeesh-23]

import deepxde as dde
import matplotlib.pyplot as plt
import numpy as np
from deepxde.backend import tf
def main():
rhoc =4.005*(10**(-3))
k= 0.05
v= 10
ff= 0.6
fr= 1.4
Q= 1652.4
af= 1.002
ar= 3.34
b= 1.67
c= 1.67
h= 20*(10**(-6))
alpha= 12.484
T_ref= 273.15
Rboltz =5.67*(10**(-14))
emiss= 0.3
t0 = 0.0
te= 2.0
eta= 0.9
v = 10.
U= 15.3
I= 120
x0 =10
y0 = 0
z0 =5
Ta= 273.15

dx = 40
dy = 20
dz = 5
dt = 2

num_domain= 30000
num_boundary= 20000
num_initial= 10000
num_test= 10000
def pde(X, T):
    x, y, z, t= X[:, 0:1], X[:, 1:2], X[:, 2:3], X[:, 3:4]
    dT_x= dde.grad.jacobian(T, X, j=0)
    dT_y= dde.grad.jacobian(T, X, j= 1)
    dT_z= dde.grad.jacobian(T, X, j= 2)
    dT_t= dde.grad.jacobian(T, X, j= 3)
    
    
    dT_xx= dde.grad.hessian(T, X, j=0)
    dT_yy= dde.grad.hessian(T, X, j= 1)
    dT_zz= dde.grad.hessian(T, X, j= 2)
    
    r02= ((X[:, 0:1]- x0-v*X[:, 3:4])**2/af**2)+((X[:,1:2]-y0)**2/b**2)+((X[:, 2:3]- z0)**2/c**2)
    qf= (6*((3)**(1/3))*ff*Q/(af*b*c*3.14159*1.7724))*tf.math.exp(-3*r02)
    qr= (6*((3)**(1/3))*fr*Q/(ar*b*c*3.14159*1.7724))*tf.math.exp(-3*r02)
    q = qf+qr
    return rhoc*(dT_t)- k*(dT_xx+dT_yy)-q

# Make a simple cubic domain
spatial_domain = dde.geometry.Cuboid(xmin=[0, 0, 0], xmax=[dx, dy, dz])
# Specify the time domain with end time: 2 mm / (1000 mm/s) = 0.002 s
temporal_domain = dde.geometry.TimeDomain(0, dt)
spatio_temporal_domain = dde.geometry.GeometryXTime(spatial_domain, temporal_domain)

#Bc
def initial(X):
    return np.ones((len(X[:, 0:1]), 1), dtype=np.float32)*Ta

def func_loss(X):
    predictions = model.predict(X, operator= pde)  # Get model predictions
    Ta_array = np.ones(len(X[:,0:1])) * Ta  # Create an array of Ta values
    loss_term1 = -h * (predictions - Ta_array)
    loss_term2 = -rboltz * emiss * ((predictions ** 4) - (Ta_array ** 4))
    total_loss = loss_term1 + loss_term2
    return total_loss



def boundary_l(X, on_boundary):
    x, y, z, t= X[0], X[1], X[2], X[3]
    return on_boundary and np.isclose(x, 0)
def boundary_r(X, on_boundary):
    x, y, z, t= X[0], X[1], X[2], X[3]
    return on_boundary and np.isclose(x, 40)
def boundary_u(X, on_boundary):
    x, y, z, t= X[0], X[1], X[2], X[3]
    return on_boundary and np.isclose(z, 5)

def boundary_d(X, on_boundary):
    x, y, z, t= X[0], X[1], X[2], X[3]
    return on_boundary and np.isclose(z, 0)

def boundary_f(X, on_boundary):
    x, y, z, t= X[0], X[1], X[2], X[3]
    return on_boundary and np.isclose(y, 0)
def boundary_b(X, on_boundary):
    x, y, z, t= X[0], X[1], X[2], X[3]
    return on_boundary and np.isclose(y, 20)
def boundary_initial(X, on_initial):
    x, y, z, t= X[0], X[1], X[2], X[3]
    return on_initial and np.isclose(t, 0)

Define the boundary conditions

bc_l = dde.DirichletBC(spatio_temporal_domain, func_loss, boundary_l)
bc_r = dde.DirichletBC(spatio_temporal_domain, func_loss, boundary_r)
bc_u= dde.DirichletBC(spatio_temporal_domain, func_loss, boundary_u)
bc_f = dde.DirichletBC(spatio_temporal_domain, func_loss, boundary_f)
bc_b = dde.DirichletBC(spatio_temporal_domain, func_loss, boundary_b)
ic = dde.IC(spatio_temporal_domain, initial, boundary_initial)

data = dde.data.TimePDE(
    spatio_temporal_domain,
    pde,
    [
        bc_u,
        bc_l,
        bc_r,
        bc_f,
        bc_b,
        ic,
    ],
    num_domain=50000,
    num_boundary=5000,
    num_initial=5000,
    num_test=10000,
)
# ... (previous code)
layer_size = [3] + [60] * 5 + [1]
activation_func = "tanh"
initializer = "Glorot uniform"
# Set up the NN architecture
net = dde.maps.FNN(layer_size, activation_func, initializer)

model = dde.Model(data, net)

# Initialize TensorFlow session
tf.compat.v1.disable_eager_execution()
model.sess = tf.compat.v1.Session()
model.sess.run(tf.compat.v1.global_variables_initializer())

# Train the model
model.train(epochs=30000)
checker = dde.callbacks.ModelCheckpoint(
    "model/model1.ckpt", save_better_only=True, period=1000
)
losshistory, trainstate = model.train(epochs=epochs,batch_size = batch_size_,callbacks = [checker])
model.compile("L-BFGS-B")
dde.optimizers.set_LBFGS_options(
    maxcor=50,
)
losshistory, train_state = model.train(epochs = epochs, batch_size = batch_size_)
dde.saveplot(losshistory, trainstate, issave=True, isplot=True)

if name == 'main':
main()

---

AttributeError Traceback (most recent call last)
Cell In[2], line 156
153 dde.saveplot(losshistory, trainstate, issave=True, isplot=True)
155 if name == 'main':
--> 156 main()

Cell In[2], line 143, in main()
140 model.sess.run(tf.compat.v1.global_variables_initializer())
142 # Train the model
--> 143 model.train(epochs=30000)
144 checker = dde.callbacks.ModelCheckpoint(
145 "model/model1.ckpt", save_better_only=True, period=1000
146 )
147 losshistory, trainstate = model.train(epochs=epochs,batch_size = batch_size_,callbacks = [checker])

File /opt/conda/lib/python3.10/site-packages/deepxde/utils/internal.py:22, in timing..wrapper(*args, **kwargs)
19 @wraps(f)
20 def wrapper(*args, **kwargs):
21 ts = timeit.default_timer()
---> 22 result = f(*args, **kwargs)
23 te = timeit.default_timer()
24 if config.rank == 0:

File /opt/conda/lib/python3.10/site-packages/deepxde/model.py:622, in Model.train(self, iterations, batch_size, display_every, disregard_previous_best, callbacks, model_restore_path, model_save_path, epochs)
620 self.train_state.set_data_train(*self.data.train_next_batch(self.batch_size))
621 self.train_state.set_data_test(*self.data.test())
--> 622 self._test()
623 self.callbacks.on_train_begin()
624 if optimizers.is_external_optimizer(self.opt_name):

File /opt/conda/lib/python3.10/site-packages/deepxde/model.py:811, in Model._test(self)
806 def _test(self):
807 # TODO Now only print the training loss in rank 0. The correct way is to print the average training loss of all ranks.
808 (
809 self.train_state.y_pred_train,
810 self.train_state.loss_train,
--> 811 ) = self._outputs_losses(
812 True,
813 self.train_state.X_train,
814 self.train_state.y_train,
815 self.train_state.train_aux_vars,
816 )
817 self.train_state.y_pred_test, self.train_state.loss_test = self._outputs_losses(
818 False,
819 self.train_state.X_test,
820 self.train_state.y_test,
821 self.train_state.test_aux_vars,
822 )
824 if isinstance(self.train_state.y_test, (list, tuple)):

File /opt/conda/lib/python3.10/site-packages/deepxde/model.py:526, in Model._outputs_losses(self, training, inputs, targets, auxiliary_vars)
524 outputs_losses = self.outputs_losses_test
525 if backend_name == "tensorflow.compat.v1":
--> 526 feed_dict = self.net.feed_dict(training, inputs, targets, auxiliary_vars)
527 return self.sess.run(outputs_losses, feed_dict=feed_dict)
528 if backend_name == "tensorflow":

File /opt/conda/lib/python3.10/site-packages/deepxde/nn/tensorflow_compat_v1/nn.py:48, in NN.feed_dict(self, training, inputs, targets, auxiliary_vars)
46 """Construct a feed_dict to feed values to TensorFlow placeholders."""
47 feed_dict = {self.training: training}
---> 48 feed_dict.update(self._feed_dict_inputs(inputs))
49 if targets is not None:
50 feed_dict.update(self._feed_dict_targets(targets))

File /opt/conda/lib/python3.10/site-packages/deepxde/nn/tensorflow_compat_v1/nn.py:56, in NN._feed_dict_inputs(self, inputs)
55 def _feed_dict_inputs(self, inputs):
---> 56 return make_dict(self.inputs, inputs)

File /opt/conda/lib/python3.10/site-packages/deepxde/nn/tensorflow_compat_v1/fnn.py:47, in FNN.inputs(self)
45 @Property
46 def inputs(self):
---> 47 return self.x

AttributeError: 'FNN' object has no attribute 'x'

I dont know why i am getting this error and Please help to resolve it

[Jagadeesh-23]

@lululxvi dear sir, please help me with this, this is very important for my thesis study

[vl-dud]

You must compile the model before training. Change

# Train the model
model.train(epochs=30000)

to

# Train the model
model.compile("L-BFGS-B")
model.train(epochs=30000)

And I'm assuming the size of the input layer should be 4, not 3: layer_size = [4] + [60] * 5 + [1]