diff --git a/DeepINN/config.py b/DeepINN/config.py
index 1f9330d..6677e4e 100644
--- a/DeepINN/config.py
+++ b/DeepINN/config.py
@@ -1,22 +1,39 @@
 import torch
+import random
+import numpy as np
 
 class Config:
     """
     Set up configuration such as the data-types, number generation seeds etc.
     We use this Config object to apply during the training. So, one doesn't need to apply seeds in each jupyter notebook cell.
     """
-    def __init__(self, float_type=torch.float32, random_seed=42, device = 'cuda'):
-        self.float_type = float_type
+    def __init__(self, torch_type=torch.float32, torch_seed=0, random_seed=0, numpy_seed=0, device = 'cuda'):
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+        self.float_type = torch_type
+        self.torch_seed = torch_seed
         self.random_seed = random_seed
+        self.numpy_seed = numpy_seed
         self.device = device
         # Add more configuration parameters as needed
 
-        self.apply_seeds()
-        self.apply_float_type()
-        self.default_device()
+        # self.apply_seeds()
+        # self.apply_float_type()
+        # self.default_device()
+    def load_all_configs(self):
+        self.torch_seeds()
+        self.random_seeds()
+        self.numpy_seeds()
 
-    def apply_seeds(self):
+    def torch_seeds(self):
         torch.manual_seed(self.random_seed)
+    
+    def random_seeds(self):
+        random.seed(self.random_seed)
+    
+    def numpy_seeds(self):
+        np.random.seed(self.numpy_seed)
 
     def apply_float_type(self):
         torch.set_default_dtype(self.float_type)
diff --git a/DeepINN/constraint/losses.py b/DeepINN/constraint/losses.py
index 6e557bb..6467e08 100644
--- a/DeepINN/constraint/losses.py
+++ b/DeepINN/constraint/losses.py
@@ -44,9 +44,10 @@ def sampler_object(self):
         else:
             return self.sampler(self.geom.boundary, n_points = self.no_points, filter_fn = self.filter_fn)
     
-    def sample_labels(self, sampled_points):
+    def sample_labels(self, sampled_points: list):
         # evaluate the BC labels at each training point.
-        return self.function(sampled_points)
+        #return torch.tensor(list(map(self.function, sampled_points)))
+        return self.function(sampled_points) 
 
 class PDE():
     """
@@ -72,7 +73,7 @@ def __init__(self, geom, sampling_strategy, no_points, filter_fn = None) -> None
         if filter_fn is not None:
             raise NotImplementedError("Filter function isn't implemented for collocation points. Use filter_fn=None.")
         
-                # assign the correct sampling strategy
+        # assign the correct sampling strategy
         if self.sampling_strategy in strategy_dict:
             self.sampler = strategy_dict[self.sampling_strategy]
         else:
diff --git a/DeepINN/model.py b/DeepINN/model.py
index 15467fa..ec6823d 100644
--- a/DeepINN/model.py
+++ b/DeepINN/model.py
@@ -52,18 +52,21 @@ def initialise_training(self, iterations : int = None):
             self.training_history = []  # Initialize an empty list for storing loss values
             self.iterations = iterations
             # Load all the seeds, data types, devices etc.
-            # self.config.apply_seeds()
+            self.config.torch_seeds()
+            self.config.random_seeds()
+            self.config.numpy_seeds()
             # self.config.apply_float_type()
             # self.config.default_device()
 
             # In 1D problem we need to combine the BCs as there is only one point for each BC, which returns an undefined feature scaling because the ub and lb are same in the denominator, so we get infinity
             # For problem with multiple points on each boundary, we don't need to combine them.
-            if self.boundary_point_sample[0].size()[0] == 1: # if row is 1 in the particular boundary tensor
-                self.boundary_point_sample = torch.cat(self.boundary_point_sample, dim=0)
-                self.boundary_point_labels = torch.cat(self.boundary_point_labels, dim=0)
-            else:
-                self.boundary_point_sample = torch.cat(self.boundary_point_sample, dim=0)
-                self.boundary_point_labels = torch.cat(self.boundary_point_labels, dim=0)
+            #if self.boundary_point_sample[0].size()[0] == 1: # if row is 1 in the particular boundary tensor
+            self.boundary_point_sample = torch.cat(self.boundary_point_sample, dim=0)
+            self.boundary_point_labels = torch.cat(self.boundary_point_labels, dim=0)
+            # TODO: Currently all BCs are included in a single tensor. Meaning we can visualise/ print the BC loss on individual boundaries similar to DeepXDE.
+            # else:
+            #     self.boundary_point_sample = torch.cat(self.boundary_point_sample, dim=0)
+            #     self.boundary_point_labels = torch.cat(self.boundary_point_labels, dim=0)
 
             # Set requires_grad=True for self.collocation_point_sample
             self.collocation_point_sample.requires_grad = True
diff --git a/DeepINN/nn/FCNN.py b/DeepINN/nn/FCNN.py
index a87d58c..3fa8e49 100644
--- a/DeepINN/nn/FCNN.py
+++ b/DeepINN/nn/FCNN.py
@@ -40,7 +40,8 @@ def weight_init(self):
             self.initialiser(self.linears[i].weight.data, gain=1.0)
             
             # set biases to zero
-            torch.nn.init.zeros_(self.linears[i].bias.data)
+            # torch.nn.init.zeros_(self.linears[i].bias.data)
+            torch.nn.init.constant_(self.linears[i].bias.data, 0.01)
 
     def forward(self, input):
         """
diff --git a/Tutorials/5. FCNN/3. model.ipynb b/Tutorials/5. FCNN/3. model.ipynb
index 6ceb093..2e4134b 100644
--- a/Tutorials/5. FCNN/3. model.ipynb	
+++ b/Tutorials/5. FCNN/3. model.ipynb	
@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# FCNN training"
+    "# 1D Laplace Equation "
    ]
   },
   {
diff --git a/Tutorials/6. 2D heat conduction/1. Laplace_FCDNN.ipynb b/Tutorials/6. 2D heat conduction/1. Laplace_FCDNN.ipynb
new file mode 100644
index 0000000..7068da8
--- /dev/null
+++ b/Tutorials/6. 2D heat conduction/1. Laplace_FCDNN.ipynb	
@@ -0,0 +1,428 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2D Laplace Equation: Feedforward dense neural network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using default backend: PyTorch\n",
+      "Using Pytorch:  2.0.1+cu117\n"
+     ]
+    }
+   ],
+   "source": [
+    "# This is only valid when the package is not installed\n",
+    "import sys\n",
+    "sys.path.append('../../') # two folders up\n",
+    "import DeepINN as dp\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "from DeepINN.config import Config"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Geometry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A simple 1D geometry\n",
+    "X = dp.spaces.R2('x')\n",
+    "Rect = dp.domains.Parallelogram(X, [0,0], [1,0], [0,1]) # unit square"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seeds = Config()\n",
+    "seeds.load_all_configs()\n",
+    "left_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "                                      function = lambda X: X[:,0]*torch.tensor([0.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "                                      sampling_strategy = \"grid\",\n",
+    "                                      no_points = 20, \n",
+    "                                      filter_fn = lambda x: x[:, 0] == 0.0)\n",
+    "right_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "                                      function = lambda X: X[:,0]*torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "                                      sampling_strategy = \"grid\",\n",
+    "                                      no_points = 20, # you can use more points. there are conditions to deal with stupid conditions. \n",
+    "                                      filter_fn = lambda x: x[:, 0] == 1.0)\n",
+    "\n",
+    "interior_points = dp.constraint.PDE(geom = Rect,\n",
+    "                                    sampling_strategy= \"LatinHypercube\",\n",
+    "                                    no_points = 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dp.utils.scatter(X, interior_points.sampler_object(), dpi = 50) # collocation points\n",
+    "dp.utils.scatter(X, left_bc.sampler_object(), dpi = 50)\n",
+    "dp.utils.scatter(X, right_bc.sampler_object(), dpi = 50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## PDE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def laplace(X,y):\n",
+    "    \"\"\"\n",
+    "    2D Laplace equation.\n",
+    "    u__x + u__y = 0\n",
+    "     i is always zero because output to the NN is always 1D\n",
+    "    \"\"\"\n",
+    "    dy_x = dp.constraint.Jacobian(X, y)(i=0, j=0)\n",
+    "    dy_xx = dp.constraint.Jacobian(X, dy_x)(i = 0, j = 0)\n",
+    "\n",
+    "    dy_y = dp.constraint.Jacobian(X, y)(i=0, j=1)\n",
+    "    dy_yy = dp.constraint.Jacobian(X, dy_y)(i = 0, j = 1)\n",
+    "\n",
+    "    return dy_xx + dy_yy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "domain = dp.domain.Generic(laplace,\n",
+    "                            interior_points,\n",
+    "                            [left_bc, right_bc])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "activation = \"tanh\"\n",
+    "initialiser = \"Xavier normal\"\n",
+    "layer_size = [2] + [2] * 5 + [1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "net = dp.nn.FullyConnected(layer_size, activation, initialiser)\n",
+    "model = dp.Model(domain, net)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Domain compiled\n",
+      "Network compiled\n"
+     ]
+    }
+   ],
+   "source": [
+    "optimiser = \"adam\"\n",
+    "lr=0.001\n",
+    "metrics=\"MSE\"\n",
+    "\n",
+    "model.compile(optimiser, lr, metrics, device = \"cuda\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.optim.adam.Adam, 0.001, MSELoss())"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.optimiser_function, model.lr, model.metric"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 1 \t BC Loss: 0.5171\t PDE Loss: 0.6079 \t Loss: 1.1250\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 501 \t BC Loss: 0.2473\t PDE Loss: 0.0006 \t Loss: 0.2479\n",
+      "Iteration: 1001 \t BC Loss: 0.1602\t PDE Loss: 0.0015 \t Loss: 0.1617\n",
+      "Iteration: 1501 \t BC Loss: 0.0001\t PDE Loss: 0.0013 \t Loss: 0.0014\n",
+      "Iteration: 2001 \t BC Loss: 0.0000\t PDE Loss: 0.0003 \t Loss: 0.0003\n",
+      "Iteration: 2501 \t BC Loss: 0.0000\t PDE Loss: 0.0001 \t Loss: 0.0001\n",
+      "Iteration: 3001 \t BC Loss: 0.0000\t PDE Loss: 0.0001 \t Loss: 0.0001\n",
+      "Iteration: 3501 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
+      "Iteration: 4001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
+      "Iteration: 4501 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
+      "Iteration: 5001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
+      "Training finished\n",
+      "Time taken: 'trainer' in 41.4940 secs\n"
+     ]
+    }
+   ],
+   "source": [
+    "#torch.manual_seed(1234)\n",
+    "model.train(iterations = 5000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model.iter = 1\n",
+    "# model.train(iterations = 2000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "FullyConnected(\n",
+       "  (activation): Tanh()\n",
+       "  (linears): ModuleList(\n",
+       "    (0-4): 5 x Linear(in_features=2, out_features=2, bias=True)\n",
+       "    (5): Linear(in_features=2, out_features=1, bias=True)\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coordinates_list = dp.utils.tensor2numpy([model.collocation_point_sample, model.boundary_point_sample])\n",
+    "solution_list = dp.utils.tensor2numpy([model.collocation_forward, model.BC_forward])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history = model.training_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(1)\n",
+    "plt.scatter(coordinates_list[0][:,0], coordinates_list[0][:,1], c=solution_list[0][:,0], label = \"collocation points\",  cmap=plt.get_cmap('plasma', 10), edgecolors='k')\n",
+    "plt.scatter(coordinates_list[1][:,0], coordinates_list[1][:,1], c=solution_list[1], label = \"boundary points\", cmap=plt.get_cmap('plasma', 10),edgecolors='k')\n",
+    "plt.colorbar()\n",
+    "plt.grid('minor')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Loss')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(2)\n",
+    "plt.plot(history)\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.yscale(\"log\")\n",
+    "plt.ylabel(\"Loss\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.Size([40, 1]), torch.Size([40, 2]))"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.boundary_point_labels.shape, model.boundary_point_sample.shape"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Tutorials/6. 2D heat conduction/1. model.ipynb b/Tutorials/6. 2D heat conduction/1. model.ipynb
deleted file mode 100644
index 4802121..0000000
--- a/Tutorials/6. 2D heat conduction/1. model.ipynb	
+++ /dev/null
@@ -1,397 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# FCNN training"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Using default backend: PyTorch\n",
-      "Using Pytorch:  2.0.1+cu117\n"
-     ]
-    }
-   ],
-   "source": [
-    "# This is only valid when the package is not installed\n",
-    "import sys\n",
-    "sys.path.append('../../') # two folders up\n",
-    "import DeepINN as dp\n",
-    "import torch\n",
-    "import numpy as np"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Geometry"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# A simple 1D geometry\n",
-    "X = dp.spaces.R2('x')\n",
-    "Rect = dp.domains.Parallelogram(X, [0,0], [1,0], [0,1]) # unit square"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "left_bc = dp.constraint.DirichletBC(geom = Rect,\n",
-    "                                      function = lambda X: X[:,0]*torch.tensor([0.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
-    "                                      sampling_strategy = \"grid\",\n",
-    "                                      no_points = 10, \n",
-    "                                      filter_fn = lambda x: x[:, 0] == 0.0)\n",
-    "right_bc = dp.constraint.DirichletBC(geom = Rect,\n",
-    "                                      function = lambda X: X[:,0]*torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
-    "                                      sampling_strategy = \"grid\",\n",
-    "                                      no_points = 10, # you can use more points. there are conditions to deal with stupid conditions. \n",
-    "                                      filter_fn = lambda x: x[:, 0] == 1.0)\n",
-    "\n",
-    "interior_points = dp.constraint.PDE(geom = Rect,\n",
-    "                                    sampling_strategy= \"LatinHypercube\",\n",
-    "                                    no_points = 100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 320x240 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 320x240 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 320x240 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "dp.utils.scatter(X, interior_points.sampler_object(), dpi = 50) # collocation points\n",
-    "dp.utils.scatter(X, left_bc.sampler_object(), dpi = 50)\n",
-    "dp.utils.scatter(X, right_bc.sampler_object(), dpi = 50)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## PDE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def laplace(X,y):\n",
-    "    \"\"\"\n",
-    "    2D Laplace equation.\n",
-    "    u__x + u__y = 0\n",
-    "     i is always zero because output to the NN is always 1D\n",
-    "    \"\"\"\n",
-    "    dy_x = dp.constraint.Jacobian(X, y)(i=0, j=0)\n",
-    "    dy_xx = dp.constraint.Jacobian(X, dy_x)(i = 0, j = 0)\n",
-    "\n",
-    "    dy_y = dp.constraint.Jacobian(X, y)(i=0, j=1)\n",
-    "    dy_yy = dp.constraint.Jacobian(X, dy_y)(i = 0, j = 1)\n",
-    "\n",
-    "    return dy_xx + dy_yy"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "domain = dp.domain.Generic(laplace,\n",
-    "                            interior_points,\n",
-    "                            [left_bc, right_bc])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Network"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "activation = \"tanh\"\n",
-    "initialiser = \"Xavier normal\"\n",
-    "layer_size = [2] + [2] * 1 + [1]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "net = dp.nn.FullyConnected(layer_size, activation, initialiser)\n",
-    "model = dp.Model(domain, net)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Domain compiled\n",
-      "Network compiled\n"
-     ]
-    }
-   ],
-   "source": [
-    "optimiser = \"adam\"\n",
-    "lr=0.001\n",
-    "metrics=\"MSE\"\n",
-    "\n",
-    "model.compile(optimiser, lr, metrics, device = \"cuda\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(torch.optim.adam.Adam, 0.001, MSELoss())"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model.optimiser_function, model.lr, model.metric"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Iteration: 1 \t BC Loss: 0.4289\t PDE Loss: 0.1653 \t Loss: 0.5942\n",
-      "Iteration: 501 \t BC Loss: 0.0210\t PDE Loss: 0.0000 \t Loss: 0.0210\n",
-      "Iteration: 1001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Iteration: 1501 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Iteration: 2001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Iteration: 2501 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Iteration: 3001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Iteration: 3501 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Iteration: 4001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Iteration: 4501 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Iteration: 5001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
-      "Training finished\n",
-      "Time taken: 'trainer' in 29.4198 secs\n"
-     ]
-    }
-   ],
-   "source": [
-    "model.train(iterations = 5000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# model.iter = 1\n",
-    "# model.train(iterations = 2000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "FullyConnected(\n",
-       "  (activation): Tanh()\n",
-       "  (linears): ModuleList(\n",
-       "    (0): Linear(in_features=2, out_features=2, bias=True)\n",
-       "    (1): Linear(in_features=2, out_features=1, bias=True)\n",
-       "  )\n",
-       ")"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model.network"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "coordinates_list = dp.utils.tensor2numpy([model.collocation_point_sample, model.boundary_point_sample])\n",
-    "solution_list = dp.utils.tensor2numpy([model.collocation_forward, model.BC_forward])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "history = model.training_history"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure(1)\n",
-    "plt.scatter(coordinates_list[0][:,0], coordinates_list[0][:,1], c=solution_list[0][:,0], label = \"collocation points\",  cmap=plt.get_cmap('plasma', 10))\n",
-    "plt.scatter(coordinates_list[1][:,0], coordinates_list[1][:,1], c=solution_list[1], label = \"boundary points\", cmap=plt.get_cmap('plasma', 10))\n",
-    "plt.colorbar()\n",
-    "plt.grid('minor')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0, 0.5, 'Loss')"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure(2)\n",
-    "plt.plot(history)\n",
-    "plt.xlabel(\"Iterations\")\n",
-    "plt.ylabel(\"Loss\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.16"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Tutorials/6. 2D heat conduction/2. Laplace_FCDNN_simple_BC.ipynb b/Tutorials/6. 2D heat conduction/2. Laplace_FCDNN_simple_BC.ipynb
new file mode 100644
index 0000000..a984617
--- /dev/null
+++ b/Tutorials/6. 2D heat conduction/2. Laplace_FCDNN_simple_BC.ipynb	
@@ -0,0 +1,454 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2D Laplace Equation: Feedforward dense neural network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using default backend: PyTorch\n",
+      "Using Pytorch:  2.0.1+cu117\n"
+     ]
+    }
+   ],
+   "source": [
+    "# This is only valid when the package is not installed\n",
+    "import sys\n",
+    "sys.path.append('../../') # two folders up\n",
+    "import DeepINN as dp\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "from DeepINN.config import Config"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Geometry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A simple 1D geometry\n",
+    "X = dp.spaces.R2('x')\n",
+    "Rect = dp.domains.Parallelogram(X, [0,0], [1,0], [0,1]) # unit square"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seeds = Config()\n",
+    "seeds.load_all_configs()\n",
+    "left_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "                                      function = lambda X: torch.zeros_like(X[:,0]),#*torch.tensor([0.0]), #+ torch.tensor([0.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "                                      sampling_strategy = \"grid\",\n",
+    "                                      no_points = 20, \n",
+    "                                      filter_fn = lambda x: x[:, 0] == 0.0)\n",
+    "right_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "                                      function = lambda X: torch.ones_like(X[:,0]),#*torch.tensor([1.0]), #+ torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "                                      sampling_strategy = \"grid\",\n",
+    "                                      no_points = 20, # you can use more points. there are conditions to deal with stupid conditions. \n",
+    "                                      filter_fn = lambda x: x[:, 0] == 1.0)\n",
+    "# top_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "#                                       function = lambda X: X[:,0]*torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "#                                       sampling_strategy = \"grid\",\n",
+    "#                                       no_points = 10, # you can use more points. there are conditions to deal with stupid conditions. \n",
+    "#                                       filter_fn = lambda x: x[:, 0] == 1.0)\n",
+    "\n",
+    "interior_points = dp.constraint.PDE(geom = Rect,\n",
+    "                                    sampling_strategy= \"LatinHypercube\",\n",
+    "                                    no_points = 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# left_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "#                                       function = lambda X: X[:,0]*torch.tensor([0.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "#                                       sampling_strategy = \"grid\",\n",
+    "#                                       no_points = 10, \n",
+    "#                                       filter_fn = lambda x: x[:, 0] == 0.0)\n",
+    "# right_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "#                                       function = lambda X: X[:,0]*torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "#                                       sampling_strategy = \"grid\",\n",
+    "#                                       no_points = 10, # you can use more points. there are conditions to deal with stupid conditions. \n",
+    "#                                       filter_fn = lambda x: x[:, 0] == 1.0)\n",
+    "\n",
+    "# interior_points = dp.constraint.PDE(geom = Rect,\n",
+    "#                                     sampling_strategy= \"LatinHypercube\",\n",
+    "#                                     no_points = 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dp.utils.scatter(X, interior_points.sampler_object(), dpi = 50) # collocation points\n",
+    "dp.utils.scatter(X, left_bc.sampler_object(), dpi = 50)\n",
+    "dp.utils.scatter(X, right_bc.sampler_object(), dpi = 50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## PDE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def laplace(X,y):\n",
+    "    \"\"\"\n",
+    "    2D Laplace equation.\n",
+    "    u__x + u__y = 0\n",
+    "     i is always zero because output to the NN is always 1D\n",
+    "    \"\"\"\n",
+    "    dy_x = dp.constraint.Jacobian(X, y)(i=0, j=0)\n",
+    "    dy_xx = dp.constraint.Jacobian(X, dy_x)(i = 0, j = 0)\n",
+    "\n",
+    "    dy_y = dp.constraint.Jacobian(X, y)(i=0, j=1)\n",
+    "    dy_yy = dp.constraint.Jacobian(X, dy_y)(i = 0, j = 1)\n",
+    "\n",
+    "    return dy_xx + dy_yy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "domain = dp.domain.Generic(laplace,\n",
+    "                            interior_points,\n",
+    "                            [left_bc, right_bc])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "activation = \"tanh\"\n",
+    "initialiser = \"Xavier normal\"\n",
+    "layer_size = [2] + [2] * 5 + [1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "net = dp.nn.FullyConnected(layer_size, activation, initialiser)\n",
+    "model = dp.Model(domain, net)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Domain compiled\n",
+      "Network compiled\n"
+     ]
+    }
+   ],
+   "source": [
+    "optimiser = \"adam\"\n",
+    "lr=0.001\n",
+    "metrics=\"MSE\"\n",
+    "\n",
+    "model.compile(optimiser, lr, metrics, device = \"cuda\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.optim.adam.Adam, 0.001, MSELoss())"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.optimiser_function, model.lr, model.metric"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 1 \t BC Loss: 0.5171\t PDE Loss: 0.6079 \t Loss: 1.1250\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 501 \t BC Loss: 0.2473\t PDE Loss: 0.0006 \t Loss: 0.2479\n",
+      "Iteration: 1001 \t BC Loss: 0.1602\t PDE Loss: 0.0015 \t Loss: 0.1617\n",
+      "Iteration: 1501 \t BC Loss: 0.0001\t PDE Loss: 0.0013 \t Loss: 0.0014\n",
+      "Iteration: 2001 \t BC Loss: 0.0000\t PDE Loss: 0.0003 \t Loss: 0.0003\n",
+      "Iteration: 2501 \t BC Loss: 0.0000\t PDE Loss: 0.0001 \t Loss: 0.0001\n",
+      "Iteration: 3001 \t BC Loss: 0.0000\t PDE Loss: 0.0001 \t Loss: 0.0001\n",
+      "Iteration: 3501 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
+      "Iteration: 4001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
+      "Iteration: 4501 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
+      "Iteration: 5001 \t BC Loss: 0.0000\t PDE Loss: 0.0000 \t Loss: 0.0000\n",
+      "Training finished\n",
+      "Time taken: 'trainer' in 41.6386 secs\n"
+     ]
+    }
+   ],
+   "source": [
+    "#torch.manual_seed(0)\n",
+    "model.train(iterations = 5000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model.iter = 1\n",
+    "# model.train(iterations = 2000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "FullyConnected(\n",
+       "  (activation): Tanh()\n",
+       "  (linears): ModuleList(\n",
+       "    (0-4): 5 x Linear(in_features=2, out_features=2, bias=True)\n",
+       "    (5): Linear(in_features=2, out_features=1, bias=True)\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coordinates_list = dp.utils.tensor2numpy([model.collocation_point_sample, model.boundary_point_sample])\n",
+    "solution_list = dp.utils.tensor2numpy([model.collocation_forward, model.BC_forward])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history = model.training_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(1)\n",
+    "plt.scatter(coordinates_list[0][:,0], coordinates_list[0][:,1], c=solution_list[0][:,0], label = \"collocation points\",  cmap=plt.get_cmap('plasma', 10), edgecolors='k')\n",
+    "plt.scatter(coordinates_list[1][:,0], coordinates_list[1][:,1], c=solution_list[1], label = \"boundary points\", cmap=plt.get_cmap('plasma', 10),edgecolors='k')\n",
+    "plt.colorbar()\n",
+    "plt.grid('minor')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Loss')"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(2)\n",
+    "plt.plot(history)\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Loss\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.Size([40, 1]), torch.Size([40, 2]))"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.boundary_point_labels.shape, model.boundary_point_sample.shape"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Tutorials/6. 2D heat conduction/3. Laplace_discontinuous_FCDNN.ipynb b/Tutorials/6. 2D heat conduction/3. Laplace_discontinuous_FCDNN.ipynb
new file mode 100644
index 0000000..42f3967
--- /dev/null
+++ b/Tutorials/6. 2D heat conduction/3. Laplace_discontinuous_FCDNN.ipynb	
@@ -0,0 +1,449 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2D Laplace Equation: Feedforward dense neural network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using default backend: PyTorch\n",
+      "Using Pytorch:  2.0.1+cu117\n"
+     ]
+    }
+   ],
+   "source": [
+    "# This is only valid when the package is not installed\n",
+    "import sys\n",
+    "sys.path.append('../../') # two folders up\n",
+    "import DeepINN as dp\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "from DeepINN.config import Config"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Geometry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A simple 1D geometry\n",
+    "X = dp.spaces.R2('x')\n",
+    "Rect = dp.domains.Parallelogram(X, [0,0], [1,0], [0,1]) # unit square"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seeds = Config()\n",
+    "seeds.load_all_configs()\n",
+    "left_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "                                      function = lambda X: torch.zeros_like(X[:,0]),#*torch.tensor([0.0]), #+ torch.tensor([0.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "                                      sampling_strategy = \"grid\",\n",
+    "                                      no_points = 10, \n",
+    "                                      filter_fn = lambda x: x[:, 0] == 0.0)\n",
+    "right_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "                                      function = lambda X: torch.ones_like(X[:,0]),#*torch.tensor([1.0]), #+ torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "                                      sampling_strategy = \"grid\",\n",
+    "                                      no_points = 10, # you can use more points. there are conditions to deal with stupid conditions. \n",
+    "                                      filter_fn = lambda x: x[:, 0] == 1.0)\n",
+    "# top_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "#                                       function = lambda X: X[:,0]*torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "#                                       sampling_strategy = \"grid\",\n",
+    "#                                       no_points = 10, # you can use more points. there are conditions to deal with stupid conditions. \n",
+    "#                                       filter_fn = lambda x: x[:, 0] == 1.0)\n",
+    "\n",
+    "interior_points = dp.constraint.PDE(geom = Rect,\n",
+    "                                    sampling_strategy= \"LatinHypercube\",\n",
+    "                                    no_points = 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# left_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "#                                       function = lambda X: X[:,0]*torch.tensor([0.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "#                                       sampling_strategy = \"grid\",\n",
+    "#                                       no_points = 10, \n",
+    "#                                       filter_fn = lambda x: x[:, 0] == 0.0)\n",
+    "# right_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "#                                       function = lambda X: X[:,0]*torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "#                                       sampling_strategy = \"grid\",\n",
+    "#                                       no_points = 10, # you can use more points. there are conditions to deal with stupid conditions. \n",
+    "#                                       filter_fn = lambda x: x[:, 0] == 1.0)\n",
+    "\n",
+    "# interior_points = dp.constraint.PDE(geom = Rect,\n",
+    "#                                     sampling_strategy= \"LatinHypercube\",\n",
+    "#                                     no_points = 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dp.utils.scatter(X, interior_points.sampler_object(), dpi = 50) # collocation points\n",
+    "dp.utils.scatter(X, left_bc.sampler_object(), dpi = 50)\n",
+    "dp.utils.scatter(X, right_bc.sampler_object(), dpi = 50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## PDE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def laplace(X,y):\n",
+    "    \"\"\"\n",
+    "    2D Laplace equation.\n",
+    "    u__x + u__y = 0\n",
+    "     i is always zero because output to the NN is always 1D\n",
+    "    \"\"\"\n",
+    "    dy_x = dp.constraint.Jacobian(X, y)(i=0, j=0)\n",
+    "    dy_xx = dp.constraint.Jacobian(X, dy_x)(i = 0, j = 0)\n",
+    "\n",
+    "    dy_y = dp.constraint.Jacobian(X, y)(i=0, j=1)\n",
+    "    dy_yy = dp.constraint.Jacobian(X, dy_y)(i = 0, j = 1)\n",
+    "\n",
+    "    return dy_xx + dy_yy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "domain = dp.domain.Generic(laplace,\n",
+    "                            interior_points,\n",
+    "                            [left_bc, right_bc])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "activation = \"tanh\"\n",
+    "initialiser = \"Xavier normal\"\n",
+    "layer_size = [2] + [2] * 1 + [1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "net = dp.nn.FullyConnected(layer_size, activation, initialiser)\n",
+    "model = dp.Model(domain, net)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Domain compiled\n",
+      "Network compiled\n"
+     ]
+    }
+   ],
+   "source": [
+    "optimiser = \"adam\"\n",
+    "lr=0.001\n",
+    "metrics=\"MSE\"\n",
+    "\n",
+    "model.compile(optimiser, lr, metrics, device = \"cuda\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.optim.adam.Adam, 0.001, MSELoss())"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.optimiser_function, model.lr, model.metric"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 1 \t BC Loss: 0.2574\t PDE Loss: 7.9797 \t Loss: 8.2371\n",
+      "Iteration: 501 \t BC Loss: 0.2316\t PDE Loss: 0.0020 \t Loss: 0.2336\n",
+      "Iteration: 1001 \t BC Loss: 0.2290\t PDE Loss: 0.0024 \t Loss: 0.2313\n",
+      "Iteration: 1501 \t BC Loss: 0.2252\t PDE Loss: 0.0031 \t Loss: 0.2283\n",
+      "Iteration: 2001 \t BC Loss: 0.2199\t PDE Loss: 0.0043 \t Loss: 0.2242\n",
+      "Iteration: 2501 \t BC Loss: 0.2128\t PDE Loss: 0.0063 \t Loss: 0.2191\n",
+      "Iteration: 3001 \t BC Loss: 0.2037\t PDE Loss: 0.0097 \t Loss: 0.2134\n",
+      "Iteration: 3501 \t BC Loss: 0.1930\t PDE Loss: 0.0148 \t Loss: 0.2078\n",
+      "Iteration: 4001 \t BC Loss: 0.1819\t PDE Loss: 0.0216 \t Loss: 0.2035\n",
+      "Iteration: 4501 \t BC Loss: 0.1722\t PDE Loss: 0.0287 \t Loss: 0.2009\n",
+      "Iteration: 5001 \t BC Loss: 0.1653\t PDE Loss: 0.0345 \t Loss: 0.1997\n",
+      "Training finished\n",
+      "Time taken: 'trainer' in 22.9696 secs\n"
+     ]
+    }
+   ],
+   "source": [
+    "#torch.manual_seed(0)\n",
+    "model.train(iterations = 5000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model.iter = 1\n",
+    "# model.train(iterations = 2000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "FullyConnected(\n",
+       "  (activation): Tanh()\n",
+       "  (linears): ModuleList(\n",
+       "    (0): Linear(in_features=2, out_features=2, bias=True)\n",
+       "    (1): Linear(in_features=2, out_features=1, bias=True)\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coordinates_list = dp.utils.tensor2numpy([model.collocation_point_sample, model.boundary_point_sample])\n",
+    "solution_list = dp.utils.tensor2numpy([model.collocation_forward, model.BC_forward])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history = model.training_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(1)\n",
+    "plt.scatter(coordinates_list[0][:,0], coordinates_list[0][:,1], c=solution_list[0][:,0], label = \"collocation points\",  cmap=plt.get_cmap('plasma', 10), edgecolors='k')\n",
+    "plt.scatter(coordinates_list[1][:,0], coordinates_list[1][:,1], c=solution_list[1], label = \"boundary points\", cmap=plt.get_cmap('plasma', 10),edgecolors='k')\n",
+    "plt.colorbar()\n",
+    "plt.grid('minor')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Loss')"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(2)\n",
+    "plt.plot(history)\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.yscale(\"log\")\n",
+    "plt.ylabel(\"Loss\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.Size([20, 1]), torch.Size([20, 2]))"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.boundary_point_labels.shape, model.boundary_point_sample.shape"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Tutorials/6. 2D heat conduction/4. Laplace_discontinuous_FourierNN.ipynb b/Tutorials/6. 2D heat conduction/4. Laplace_discontinuous_FourierNN.ipynb
new file mode 100644
index 0000000..3d15a70
--- /dev/null
+++ b/Tutorials/6. 2D heat conduction/4. Laplace_discontinuous_FourierNN.ipynb	
@@ -0,0 +1,397 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2D Laplace Equation: Fourier neural network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using default backend: PyTorch\n",
+      "Using Pytorch:  2.0.1+cu117\n"
+     ]
+    }
+   ],
+   "source": [
+    "# This is only valid when the package is not installed\n",
+    "import sys\n",
+    "sys.path.append('../../') # two folders up\n",
+    "import DeepINN as dp\n",
+    "import torch\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Geometry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A simple 1D geometry\n",
+    "X = dp.spaces.R2('x')\n",
+    "Rect = dp.domains.Parallelogram(X, [0,0], [1,0], [0,1]) # unit square"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "left_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "                                      function = lambda X: X[:,0]*torch.tensor([0.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "                                      sampling_strategy = \"grid\",\n",
+    "                                      no_points = 10, \n",
+    "                                      filter_fn = lambda x: x[:, 0] == 0.0)\n",
+    "right_bc = dp.constraint.DirichletBC(geom = Rect,\n",
+    "                                      function = lambda X: X[:,0]*torch.tensor([1.0]), # this is a bug. We need to somehow involved X in the lambda otherwise it will give shape error.\n",
+    "                                      sampling_strategy = \"grid\",\n",
+    "                                      no_points = 10, # you can use more points. there are conditions to deal with stupid conditions. \n",
+    "                                      filter_fn = lambda x: x[:, 0] == 1.0)\n",
+    "\n",
+    "interior_points = dp.constraint.PDE(geom = Rect,\n",
+    "                                    sampling_strategy= \"LatinHypercube\",\n",
+    "                                    no_points = 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARsAAADXCAYAAAAqcPVaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAAexAAAHsQEGxWGGAAAZoElEQVR4nO3df2xUVdoH8G9b3qG0nRbUFF47SGNiIqYN3RVj3vXH2yhxlj8myjiWrpPWRuuPdkvR2d2iqAmJcdvtS0wa1wVFU2zV7JLdMaIQZ9eVIJE/EKKkt7gbE7bCBCiOOP1pKaXz/oEzdKYznR/n3nPPOff5/OWMLfMwQ5/zPM859zYvEolEQAghBss3OwBCiDVQsiGEcEHJhhDCBSUbQggXi8x8cbfbjcrKyrRfFw6HsXTpUsPj0ZuMcVPM/MgYdzYxDw0Nwe/3xx6bmmwqKyvxyiuvpP06TdNQVVXFISJ9yRg3xcyPjHFnE7PP54t7TG0UIYQLSjaEEC6Yks3Jkyfx2GOPwePxxD2vaRq8Xi+8Xi80TWMKkBCiBqZkc+ONN+Ktt96a93xPTw9ee+01/OlPf8Krr77K8hKEEEUYMiAeGRmJTazHxsaMeAlL+m7sIlreOYbzY1MotxdiZ8OtuK5ksdlhEZIRQ5JNWVkZRkZGkJeXB7vdPu//BwIBBAIBDA4OZtRmhUIhKdsxveP+8PgZODAFhx0AxrHrg4Nwrbletz8f4PdeT07P4J9fn8fk9AyKbIuwbnU5lthy++dI/z74YYmZKdl8//33eP755/Hll1+is7MTJ06cQH9/PzZv3oxNmzYBADo6OuZ9n9PphNPphM/ny2gbTcYtQkD/uFv3n8epCwWxxzdcswjPefV9X3i9154dh3H020s/PbqEY6OT+GvLL3L6s+jfBz8sMTMlm2uvvRY7d+6c93xVVRX6+vpY/miSRLm9EKcu/Bj3WFbnx6YWfEzUY+qhPrKwxBnN793V2OofiJvZyEqlxEkyQ8lGJ8mGt6xa3jmGo9/+AAA4deFHbPUP5NxqiGZnw614ql/f94uIjZKNThITw1P9x7DtrlKmP1PlVuO6ksXKJE6SGUo2OkmeGNiSjSythkhb8iLFQuLR5Qo6SUwEeiSGnQ23Yu2qZbjhmiVYu2qZsK1GtKo7deFHHP32BzzVf4xiIfNQZaOTZDOIc0PfMP2ZsrQaIrV7IsWSzNzKa33FDFZU3mSZyouSjU6SJYZzJsXCm0jtnkixJDN3tjdsv4yn+o9JsaDogdoowkykdk+kWJIRvfIyElU2hJlI7Z5IsSQjeuWVjF6tH1U2hHA0t/JaXirH+aK5Q/fh0amch+5U2aRBW6nWwOtznlt5aZomxb8lvVo/qmzSoK1Ua6DPOTW9jnVQZZOGlQd6C1Gt4qPPObW5xzqWl87ghftza/0o2aQh40CPh2SXZ4g8mE2HPufU9Gr9qI1KQ/StVLOoVgnQ52w8qmzSEH0r1SyqVQL0Occzok2myobkRIVK4Luxi/DsOIy7uz+FZ8dhhMYvmh2SMIwYmFNlQ3KiQiWg2txJT0a0yZRsiPCM2vlSbe6kJyPaZGqjiPCMOgNjxG1BVGFEm0yVDRFeYsXx5ekwPDsOM1c4dGvS1IxokynZEOEllvSXZyOxCoflB0KFuZNMpG6jaDfBGqIlfUF+XtzzNGORi9TJxqrXs1gtyUYrkJ+tXBr3PM1Y5CJ1srHqboJVk6wKZ3vSUXkhkXpmo9op1kxZNclaYcai8tkfqZNNNrsJKl2lbNUkawUqLyRSJ5tsVjqVVgzaslWXygsJU7KZmJhAa2srbDYbamtr4fV6AQD79+/H7t27AQDNzc247777mANlpdKKYYV2wiiiV7gqLyRMycbv98Pj8cDlcmHjxo2xZHPgwAG88sorKCgowB/+8Achko3KKwbJnOgVrsoLCVOyCQaDqK6uBgAUFBTEnq+vr8dDDz2ESCSCN954gy1CnVh1vkPiqVThyoYp2TgcDgSDQdTU1GB2djb2fGdnJw4ePAgAaGpqwnvvvRf3fYFAAIFAAIODg9A0Le3rhEKhjL4unW13lSL6+7fPDX2T8pfIfXj8DByYgsMOAOPY9cFBuNZcn/Xr6RU3T6rHvL5iBsP2y7HHy0tnTPv7qv5eJ2JKNm63G21tbdi3bx9cLhcaGhrQ398Pt9uN5uZmAMAvf/nLed/ndDrhdDrh8/lQVVWV9nU0Tcvo6/SqSFr3n8epC1crtRuuWYTnvOlfP1GmcYtE9ZhXVN4UV+G+cL95Vavq73UipmRTXFyM3t7e2OPozObhhx/Gww8/zPJH50SvfpzmO+pinYlQi507qU8QJ9KrH7fCSVWSG6ue3taD1OdsEulVkaRa/WhVIzRgzp1SlY3RFQmtaoRuuJU7pSobo88o0KpmPYnV7O/d1djqH1Dy0J3RlEo2RqPBsfUkbjps9Q8oe+jOaJRssqDyUXKZTU7PwLPjsCGzNKpm9UPJJgsqHyWX2T+/Po+j314CoP8lCOmqWdo0yJxUA2KVbyxEcjc5PRP3WM/qI92mA20aZE6qykb0i+iIOYpsiwBcij3Wc5aWrpqlNitzUiUb+mDTs2JZv251OY6NTpoyS6NNg8xJlWzog03PitXfEtsi0/6OtGmQOamSDX2w6Vm1+jOroqNNg8xJlWzog03PqtWfFSs62UiVbEh6PKo/EedCVq3oZELJRjE8qj8Rqwg9KzoRk6kKpDpnQ8QgYhWh50W4dHbGGFTZkKyJOBfSs6ITMZmqgJINyVi0vTg78iNKFhegbMl/4b/Llii3KyhiMlUBJRuSsbmzGgC4eUWp6bMaI9ARC2MomWxowGcMq7QXyVoy+jfFTskBMQ34jGHlu9TRvyl2SiabxBX3y9NhukpcB1a+EbxVqjojKdlGJQ74Ls9GYquRijMGXqx8gpuGxuyUrGyiK3BBfl7c87QakVxZuarTi5KVTXQF9uw4HLd7QqsRXyoNVa1c1elFycomilYjc1l9qEp3loynZGUTRauRuaw+VBXxGjIzKZ1siLmsPlQVMdma2doq3UYRc1m9jRXxXJKZrS1TZTMxMYHW1lbYbDbU1tbC6/UCAM6ePYvOzk5EIhHU19fjjjvu0CVYkpyog1irt7GZXPbA+7Mzs9piqmz8fj88Hg927dqFvXv3xp7fvn077HY78vPz4XA4mIMkC7P6IFZU0WT7Wcc9+GvLL5ImEd6fnZnVFlNlEwwGUV1dDQAoKCiIPT84OIienh6Ul5fjd7/7Hd5888247wsEAggEAhgcHISmaWlfJxQKxX3d5PQM/vn1eUxOz6DItgjrVpdjiU288VNi3EZZXRiGY9Xl2GN7YTjn1+UVs55kjBm4EvfqwkndPrtMbLm9CJ+Ujs/52SnK6vVY3mumn1CHw4FgMIiamhrMzs7GPb9s2TKUlJRgamp+meZ0OuF0OuHz+VBVVZX2dTRNi/u6K+dnor8n6BKOjU4KWa4nxm2UbYdG484TrV21NOfX5RWznmSMGbgS99df6/fZZeq2n+f+vSzvNVOycbvdaGtrw759++ByudDQ0ID+/n74fD50dHQgLy8PLS0tLC+RlIhT/mzp2avTLRHkZaXPjinZFBcXo7e3N/Y4OiC+5ZZbsHv3bqbAFqLClqqeZzCsPoiVmZU+O/EGHRlQYTVQoTojxhN1pzEXUiYbI1YD3h+qCtUZMZ5Kp5DpUN9PeG9BWv3AG8mMShWwlJWNEXh/qFbq1UUgazuiUgVMlc1PRDxaTvQj68FHlSpgqmx+osLQOZGsq7kRZG1HVKqAKdn8RKUPNUqk4aLZiU+ldkRW1EYpTKTV3Ow2RqV2RFZU2ZiA1yov0mpuduJTsXKVTdLKZmJiAp9//jkikQgAYGBggGtQMmC55SOvVV6k1ZwG8CRpsmlubsYXX3yBxsZGjI6OYseOHbzjEh5LwuC1ymdyiwNeREp8xBxJ26iysjI8/fTTGB4eRltbGy5fvpzsyyyNJWGI1N7wQm0MSVrZlJaWAgCWL1+Ozs5O/Pvf/+YalAxY2gJa5dVEv01hYUkrm+7u7th/V1RU4OjRowCAPXv2oK6ujk9kgmM5l0OrvJpEOmogoqx2o/71r38ZFYd0KGEYz+yzOdkye8dNdHTOhgjL7LM52ZJtx41325cy2XR1dSESiWB6ehrPPvssAGDxYnFXFaIe2SoF2WZxvJN5yjbqtttuQ319PfLz89HR0QEA2LJli6HBEDKXbLt2srXWvJN5ymRz4sQJlJeXIxwO49y5c4YGQawjmzmMihfHZorHvIp3Mk+ZbFauXIlNmzYBAHp6erB+/XpDAyHWkM2OjWyVgp547GzxTuYpk80DDzwQ++/NmzcbGgSxDr1K97kr//qKGayovEnonaps8WhxeCdz2o0iXOm1YzN3uDk8OiX8TlW2ZNvZyoTwyea7sYv48PgZOpWpCL12bGTbqcqWbDtbmRD+FhMt7xyDA1M4daGATmUqQK/S3cydKh7DWxXnVcJXNqqvYCQ3c1f+5aV8d6pkO2woCuErmysr1njCY2J1c1d+TdO4DodpAcyN8JXNzoZbsby0UNjela70tR4Vh7c8CF/ZXFeyGK411+M5b5XZoSSl4pW+sl0AyZuVDxuyYEo2ExMTaG1thc1mQ21tLbxeb+z/DQwM4N5778XJkydRUlLCHKioVCypVUygelJxeMsDUxvl9/vh8Xiwa9cu7N27N/b8pUuX8Oabb1ri1LGKJbWKCdRs1G4zVjbBYBDV1dUAgIKCgtjz27dvR3t7O1566aWk3xcIBBAIBDA4OAhN09K+TigUyujrzLDl9iJ8UjqOyekZFNkWYd3qolisIsedSigUwvqKGQzbr94KdnnpjNB/Dxne5w+Pn4EDU3DYAWAcuz44iP+psAkfdyKW95op2TgcDgSDQdTU1GB2djb2/FdffYXh4WEcOXIEr7/+On7zm9/EfZ/T6YTT6YTP50NVVfpZjKZpGX0dL/NnGv+bdKYhWtyZ0DQNj6+9KW4m8cL9Ys9sZHifW/efx6kLVxfkG65ZBNea64SPOxHLe82UbNxuN9ra2rBv3z64XC40NDSgv78ff/nLXwAATU1NePLJJ1leQkiqzzRoJqE/2W6XYQSmZFNcXIze3t7Y47kDYgDYvXs3yx8vLFlnGt+NXUTz21/g63NjAIDVK+x4q+k2oasWVSTbwTo39I3ZYXEl/Na3iGRdpVreOYbjwZHY4+PBEeWqMlElqxatdpco4Q/1iUjWi+SSVWCyVGVEflTZ5EDWmUZiRRZ9LhU63Ef0ZMnKxqpnHnY23Io1jjLYFuXDtigfaxxlC1ZldMEh0ZMlKxvVd5NSua5kMT5ouzPjr5d1EE7EZMlkQz9EmcllEE6tF0nFkm2UipcYGCGXQTi1XiQVS1Y2Rl+1G13dVxeGse3QqLSrey6DcKoaSSqWTDZG7yZFV3fHqsux1T3d66nSfsh6BokYz5JtlNFyWd1VaT9kPYNEjGfJysZouazuqrQfsp5BIsajZGOA6EzIXhjG2lVLM1rdzWo/Etu3LbcXcXldEk+VNnohlGwMEF3ds7kc36xbTSaeOfqkdBy3/ZzLS5M5rHD2i5KNIMxqPxLbtcnpGe4xmE2EqkKVNnohNCC2uMR2rchmvfVHhOG8Fc5+UbKxuMTdo3Wry80OiTsRqgor7OJZbxkjcRLbN9nuiasHEc4GGdFGi9AezkXJhlieqr8HKnHoXPt/B3BNsc20xEPJhlieqmeDEtvB8YuXMX7xR9N2uyjZKEi08pmYI9nN0qLMmEtRslGQFc5skPkSF5nfu6ux1T+A82NTuDAxjfGLV38XmBlzKUo2ChJhd4Xwl7jIbPUPxBaZ0PhF0+dSlGwUJMLuCuFvoUVGhLkUnbNRUK5nNr4bu4gPj5+x3L2ZVSH6wUCqbBSU6yrW8s4xODCFUxcKuM56aKCtD9G38CnZkJjzY9FffH/1MQ800NaHCK3SQijZSMqIauBK2T2e8Nh4NNC2BprZSIr14sFkvztrZ8OtWF5ayP36HNFnDUQfTJXNxMQEWltbYbPZUFtbC6/XCwDo6urCf/7zH4RCIfT09MDhcOgSrJFkmxuwVgOpWhfXmuvxnDeze/DoRfRZA9EHU7Lx+/3weDxwuVzYuHFjLNk8++yzAID3338fBw4cQENDA3ukBpNtbsC6vS1S6yL6rIHogynZBINBVFdXAwAKCgri/t/4+Dj27NmDN954Y973BQIBBAIBDA4OZnSVcSgUMvxq5NWFYThWXT1haS8MM7+mkXFvub0In5SOY3J6BkW2RVi3uiir11pfMYNh+9W/7/LSGWiaxuW91puMMQNyxs0SM1OycTgcCAaDqKmpwezsbOz50dFR/PrXv0Z3dzfsdvu873M6nXA6nfD5fBndNjOb22vmatuh0VhlAwBrVy1lfk2j42a5feeKypviWpcX7r/SNvJ4r/UmY8yAcXEbORJgiZlpQOx2u/G3v/0NLS0tcLlcsXapqakJ4XAYL7/8Mj799FOWl+DGCjcvmivaunzWcQ/+2vILoedTJDssmwfJNg70wlTZFBcXo7e3N/Y4OrPx+/1sUZnAzLmBbMNpIjaWeZyRs0va+haACPfAJepgOUpg5MYBJRsBiLQzROTHMhIw8swTnSAWAF2lTTKVScvNMhIw8swTJRsB0KE2a4kmjNWFYWw7NJrVjM7o82BGzi4p2QiADrVZSzRhOFZdjs3oMv38ZW65KdkQorN0rQ5LwpC55aYBMSE6S7e7yDKETRz+vryhyrBzMXqjyoYQnaWrXKIzOnthGGtXLc1qRpfYcnt2HJbmmj5KNoToLF2rE00YelyuoMcMh9ehUmqjCNEZz0tf9DgXw+tQKVU2RFd06QXf3UU9jk3w2uGiZEN0Jdt9gWSnR2LjtcNFyUZQslYIMp8DsSpeh0op2QhK1gpB5nMgVsWr7aNkIyhZKwTWVVLWio6kR8lGULJWCKyrpKwVHUnPsslG9BXUqhdn6lnRif4ZW41lk43oK6hVL87Us6IT/TO2Gsse6pN1JqI6PQ/E0WcsFstWNjxnIlTOZ07Pik7WuZeqLFvZ8DxSTvcYNofVfmOG6Cxb2fCciVA5bw6V514yVsuWrWx4MvIm0qow8vcVqUjGapmSDQdUzqcn4w+PmWSsli3bRvGkcjmvFxl/eMyk1/CbZzumRGVDJbj8qNXMjl7VMs+KUonKhg5vyc+qJ6ZzpVe1zLOiVCLZiFyCy7hrYAZqNc3B8ywSUxs1MTGBRx55BI8//jjefffd2POapsHr9cLr9ULTNOYg0xG5BKfBJxEZz80LpsrG7/fD4/HA5XJh48aN8Hq9AICenh689tpryMvLQ0dHB15//XVdgk1F5BJc5KqLEJ4VJVOyCQaDqK6uBgAUFBTEnh8ZGcHSpUsBAGNjY/O+LxAIIBAIYHBwMKPKJxQKpf26bXeVAigFAJwb+gbnMvw7GCkUCmF9xQyG7Zdjzy0vneFS7eUqk/daNDLGDMgZN0vMTMnG4XAgGAyipqYGs7OzsefLysowMjKCvLw82O32ed/ndDrhdDrh8/ky+lUWevzKCzNomobH194UV3W9cL/YMxsZ32sZYwbkjJslZqZk43a70dbWhn379sHlcqGhoQH9/f3YvHkzNm3aBADo6OhgeQnp0eCTkCuYkk1xcTF6e3tjj6Mzm6qqKvT19bFFRghRihKH+ggh4qNkQwjhgpINIYQLSjaEEC5MvVxhaGgIPp8vo6+rrKw0PiCdyRg3xcyPjHFnE/PQ0FD8ExEJPPPMM2aHkBMZ46aY+ZExbpaYpWijnE6n2SHkRMa4KWZ+ZIybJea8SCQS0TEWQghJSorKhhAiP+GSjSi3rchGqpi7urrw5JNP4sEHH0QwGDQxwuRSxQ0AAwMDKC8vx/j4uEnRJZcq5rNnz6K9vR2bNm3C559/bmKEyaWKe//+/airq0NdXR3+/ve/mxjhfCdPnsRjjz0Gj8cT93zOP4u6TY500tfXF9m7d28kEolE6urqYs83NzdHfvjhh0g4HI488cQTZoWXVKqYo/x+f6Svr493WGmlint6ejrS3t4eaWxsjIyNjZkVXlKpYvb5fJGtW7dG2tvbI0NDQ2aFl1KquH/7299GTp8+HTlz5kxk8+bNJkW3sAcffDDuca4/i8JVNsFgECtXrgSQ/LYVZWVlSW9bYaZUMQPA+Pg49uzZgwceeMCEyBaWKu7t27ejvb0deXl5ZoWWUqqYBwcH0djYiG3btuGll14yK7yUUsVdX1+Phx56CBs2bMCjjz5qVnhZyfVnUbhkE71tBYCkt60YHR1NetsKM6WKeXR0FC0tLeju7hYuZiB13F999RVeffVVHDlyxPAbn2UrVcwOhwPLli1DSUkJpqbEu0FZqrg7Oztx8OBBfPbZZ+jq6jIrvKzk+rMo3G7UxMQE2traUFhYiDvvvBMff/wx+vv7oWkauru7AVy5bYVI9wFJFbPb7calS5dQUVGBuro63HPPPWaHGidV3FFNTU344x//iJKSEhOjjJcq5hMnTqC7uxt5eXlobm7GHXfcYXaocVLF/d577+Hjjz8GAKxbtw6NjY0mR3rV999/j+effx7/+Mc/0NzcjBMnTjD9LAqXbAghahKujSKEqImSDSGEC0o2hBAuKNkQrvr6+nD33Xfjo48+MjsUwpkSvxGTiOX999/H6dOnccstt+DIkSPYunVr7P81NjbGbf0S66BkQ3S3YcMGtLW14dChQ/jzn/9sdjhEENRGEd1FIhGEw2Hk5+djZmbG7HCIIKiyIbrr6enBr371K6xYsQIvvvhi7AAYAHz00Ud4++23sWTJEpSUlKC2tta8QAlXdKiPEMIFVTbEUF1dXbFrlW6++WbU19ebHBExC1U2hBAuaEBMCOGCkg0hhAtKNoQQLv4fwx7vjRnqIH0AAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 320x240 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dp.utils.scatter(X, interior_points.sampler_object(), dpi = 50) # collocation points\n",
+    "dp.utils.scatter(X, left_bc.sampler_object(), dpi = 50)\n",
+    "dp.utils.scatter(X, right_bc.sampler_object(), dpi = 50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## PDE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def laplace(X,y):\n",
+    "    \"\"\"\n",
+    "    2D Laplace equation.\n",
+    "    u__x + u__y = 0\n",
+    "     i is always zero because output to the NN is always 1D\n",
+    "    \"\"\"\n",
+    "    dy_x = dp.constraint.Jacobian(X, y)(i=0, j=0)\n",
+    "    dy_xx = dp.constraint.Jacobian(X, dy_x)(i = 0, j = 0)\n",
+    "\n",
+    "    dy_y = dp.constraint.Jacobian(X, y)(i=0, j=1)\n",
+    "    dy_yy = dp.constraint.Jacobian(X, dy_y)(i = 0, j = 1)\n",
+    "\n",
+    "    return dy_xx + dy_yy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "domain = dp.domain.Generic(laplace,\n",
+    "                            interior_points,\n",
+    "                            [left_bc, right_bc])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "activation = \"tanh\"\n",
+    "initialiser = \"Xavier normal\"\n",
+    "layer_size = [2] + [2] * 1 + [1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "net = dp.nn.FullyConnected(layer_size, activation, initialiser)\n",
+    "model = dp.Model(domain, net)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Domain compiled\n",
+      "Network compiled\n"
+     ]
+    }
+   ],
+   "source": [
+    "optimiser = \"adam\"\n",
+    "lr=0.001\n",
+    "metrics=\"MSE\"\n",
+    "\n",
+    "model.compile(optimiser, lr, metrics, device = \"cuda\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.optim.adam.Adam, 0.001, MSELoss())"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.optimiser_function, model.lr, model.metric"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 1 \t BC Loss: 0.6485\t PDE Loss: 56.3284 \t Loss: 56.9768\n",
+      "Iteration: 501 \t BC Loss: 0.4976\t PDE Loss: 0.9739 \t Loss: 1.4716\n",
+      "Iteration: 1001 \t BC Loss: 0.3631\t PDE Loss: 0.0074 \t Loss: 0.3705\n",
+      "Iteration: 1501 \t BC Loss: 0.3169\t PDE Loss: 0.0015 \t Loss: 0.3184\n",
+      "Iteration: 2001 \t BC Loss: 0.2724\t PDE Loss: 0.0013 \t Loss: 0.2738\n",
+      "Iteration: 2501 \t BC Loss: 0.2183\t PDE Loss: 0.0008 \t Loss: 0.2191\n",
+      "Iteration: 3001 \t BC Loss: 0.1593\t PDE Loss: 0.0002 \t Loss: 0.1595\n",
+      "Iteration: 3501 \t BC Loss: 0.1047\t PDE Loss: 0.0000 \t Loss: 0.1048\n",
+      "Iteration: 4001 \t BC Loss: 0.0621\t PDE Loss: 0.0002 \t Loss: 0.0623\n",
+      "Iteration: 4501 \t BC Loss: 0.0330\t PDE Loss: 0.0003 \t Loss: 0.0333\n",
+      "Iteration: 5001 \t BC Loss: 0.0152\t PDE Loss: 0.0002 \t Loss: 0.0154\n",
+      "Training finished\n",
+      "Time taken: 'trainer' in 29.1206 secs\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.train(iterations = 5000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model.iter = 1\n",
+    "# model.train(iterations = 2000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "FullyConnected(\n",
+       "  (activation): Tanh()\n",
+       "  (linears): ModuleList(\n",
+       "    (0): Linear(in_features=2, out_features=2, bias=True)\n",
+       "    (1): Linear(in_features=2, out_features=1, bias=True)\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coordinates_list = dp.utils.tensor2numpy([model.collocation_point_sample, model.boundary_point_sample])\n",
+    "solution_list = dp.utils.tensor2numpy([model.collocation_forward, model.BC_forward])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history = model.training_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(1)\n",
+    "plt.scatter(coordinates_list[0][:,0], coordinates_list[0][:,1], c=solution_list[0][:,0], label = \"collocation points\",  cmap=plt.get_cmap('plasma', 10), edgecolors='k')\n",
+    "plt.scatter(coordinates_list[1][:,0], coordinates_list[1][:,1], c=solution_list[1], label = \"boundary points\", cmap=plt.get_cmap('plasma', 10),edgecolors='k')\n",
+    "plt.colorbar()\n",
+    "plt.grid('minor')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Loss')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(2)\n",
+    "plt.plot(history)\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Loss\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/_toc.yml b/docs/_toc.yml
index 8ba0a3f..b9095dd 100644
--- a/docs/_toc.yml
+++ b/docs/_toc.yml
@@ -31,4 +31,8 @@ parts:
     chapters:
     - file: Tutorials/5. FCNN/1. basic.ipynb
     - file: Tutorials/5. FCNN/2. test.ipynb
-    - file: Tutorials/5. FCNN/3. model.ipynb
\ No newline at end of file
+    - file: Tutorials/5. FCNN/3. model.ipynb
+  - caption: 2D heat conduction
+    chapters:
+    - file: Tutorials/6. 2D heat conduction/1. Laplace_FCDNN.ipynb
+    - file; Tutorials/6. 2D heat conduction/2. Laplace_FourierNN.ipynb
\ No newline at end of file
diff --git a/todo.md b/todo.md
index 25b4516..4b8c2d0 100644
--- a/todo.md
+++ b/todo.md
@@ -28,6 +28,8 @@ Last work : `DeepINN/constraint/gradients.py`
 - [x] Constraints tutorials.
 - [ ] Add template PDE in constraint directory.
 - [x] There was some problem with FCNN tutorial. It was incorrect PDE.
+- [x] Add 2D discontinuous heat conduction problem
+- [x] Add Fourier neural network and Deep Galerkin method architecture.
 
 ## Misc
 - [x] Migrate to JupyterBooks.