{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用PINNs求解Kovasznay流问题\n",
    "\n",
    "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindflow/zh_cn/physics_driven/mindspore_kovasznay.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindflow/zh_cn/physics_driven/mindspore_kovasznay.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source.svg)](https://gitee.com/mindspore/docs/blob/master/docs/mindflow/docs/source_zh_cn/physics_driven/kovasznay.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 问题描述\n",
    "\n",
    "本案例演示如何利用PINNs求解``Kovasznay``流问题。``Kovasznay``流是``Navier-Stokes（N-S）``方程的一个特定条件下的解析解。``Kovasznay``流满足``N-S``方程的动量方程和连续性方程，并且满足``Dirichlet``边界条件。\n",
    "\n",
    "``Kovasznay``流的速度和压力分布可以表示为以下公式：\n",
    "\n",
    "$$\n",
    "u=1-e^{\\lambda x}\\cos{(2\\pi y)}.\n",
    "$$\n",
    "\n",
    "$$\n",
    "v=\\frac{\\lambda}{2\\pi}e^{\\lambda x}\\sin(2\\pi x).\n",
    "$$\n",
    "\n",
    "$$\n",
    "p = \\frac{1}{2}(1-e^{2\\lambda x}).\n",
    "$$\n",
    "\n",
    "其中，$\\lambda=\\frac{1}{2\\nu}-\\sqrt{\\frac{1}{4\\nu^2}+4\\pi^2}$。\n",
    "\n",
    "我们可以将Kovasznay流作为一个基准解，用于验证``PINNs``方法的准确性和稳定性。\n",
    "\n",
    "## 技术路径\n",
    "\n",
    "MindSpore Flow求解该问题的具体流程如下：\n",
    "\n",
    "1. 创建训练数据集。\n",
    "2. 构建模型。\n",
    "3. 优化器。\n",
    "4. 约束。\n",
    "5. 模型训练。\n",
    "6. 模型评估。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "from mindspore import context, nn, ops, jit\n",
    "from mindflow import load_yaml_config\n",
    "from mindflow.cell import FCSequential\n",
    "from mindflow.loss import get_loss_metric\n",
    "from mindspore import load_checkpoint, load_param_into_net, save_checkpoint\n",
    "\n",
    "from src.dataset import create_dataset\n",
    "\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, save_graphs=False, device_target=\"GPU\")\n",
    "\n",
    "# Load config\n",
    "file_cfg = \"kovasznay_cfg.yaml\"\n",
    "config = load_yaml_config(file_cfg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建数据集\n",
    "\n",
    "本案例在求解域及边值条件进行随机采样，生成训练数据集与测试数据集。具体方法见[src/dataset.py](https://gitee.com/mindspore/mindscience/blob/master/MindFlow/applications/physics_driven/navier_stokes/kovasznay/src/dataset.py)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds_train = create_dataset(config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构建模型\n",
    "\n",
    "本示例使用一个简单的全连接网络，深度为4层，每层的神经元个数为50，激活函数为tanh。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = FCSequential(\n",
    "    in_channels=config[\"model\"][\"in_channels\"],\n",
    "    out_channels=config[\"model\"][\"out_channels\"],\n",
    "    layers=config[\"model\"][\"layers\"],\n",
    "    neurons=config[\"model\"][\"neurons\"],\n",
    "    residual=config[\"model\"][\"residual\"],\n",
    "    act=\"tanh\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "if config[\"load_ckpt\"]:\n",
    "    param_dict = load_checkpoint(config[\"load_ckpt_path\"])\n",
    "    load_param_into_net(model, param_dict)\n",
    "\n",
    "params = model.trainable_params()\n",
    "optimizer = nn.Adam(params, learning_rate=config[\"optimizer\"][\"initial_lr\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kovasznay 求解器\n",
    "\n",
    "下述Kovasznay将作为约束条件，用于求解Kovasznay流问题。\n",
    "包含两个部分，分别为Kovasznay流方程和边界条件。\n",
    "\n",
    "边界条件根据上述参考解进行设置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "momentum_x: u(x, y)*Derivative(u(x, y), x) + v(x, y)*Derivative(u(x, y), y) + Derivative(p(x, y), x) - 0.05*Derivative(u(x, y), (x, 2)) - 0.05*Derivative(u(x, y), (y, 2))\n",
      "    Item numbers of current derivative formula nodes: 5\n",
      "momentum_y: u(x, y)*Derivative(v(x, y), x) + v(x, y)*Derivative(v(x, y), y) + Derivative(p(x, y), y) - 0.05*Derivative(v(x, y), (x, 2)) - 0.05*Derivative(v(x, y), (y, 2))\n",
      "    Item numbers of current derivative formula nodes: 5\n",
      "continuty: Derivative(u(x, y), x) + Derivative(v(x, y), y)\n",
      "    Item numbers of current derivative formula nodes: 2\n",
      "u: u(x, y) - 1 + exp(-1.81009812001397*x)*cos(2*pi*y)\n",
      "    Item numbers of current derivative formula nodes: 3\n",
      "v: v(x, y) + 0.905049060006983*exp(-1.81009812001397*x)*sin(2*pi*y)/pi\n",
      "    Item numbers of current derivative formula nodes: 2\n",
      "p: p(x, y) - 0.5 + 0.5*exp(-3.62019624002793*x)\n",
      "    Item numbers of current derivative formula nodes: 3\n"
     ]
    }
   ],
   "source": [
    "import sympy\n",
    "from sympy import Function, diff, symbols\n",
    "from mindspore import numpy as ms_np\n",
    "from mindflow import PDEWithLoss, sympy_to_mindspore\n",
    "import math\n",
    "\n",
    "class Kovasznay(PDEWithLoss):\n",
    "    \"\"\"Define the loss of the Kovasznay flow.\"\"\"\n",
    "\n",
    "    def __init__(self, model, re=20, loss_fn=nn.MSELoss()):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.re = re\n",
    "        self.nu = 1 / self.re\n",
    "        self.l = 1 / (2 * self.nu) - math.sqrt(\n",
    "            1 / (4 * self.nu**2) + 4 * math.pi**2\n",
    "        )\n",
    "        self.x, self.y = symbols(\"x y\")\n",
    "        self.u = Function(\"u\")(self.x, self.y)\n",
    "        self.v = Function(\"v\")(self.x, self.y)\n",
    "        self.p = Function(\"p\")(self.x, self.y)\n",
    "        self.in_vars = [self.x, self.y]\n",
    "        self.out_vars = [self.u, self.v, self.p]\n",
    "        super(Kovasznay, self).__init__(model, self.in_vars, self.out_vars)\n",
    "        self.bc_nodes = sympy_to_mindspore(self.bc(), self.in_vars, self.out_vars)\n",
    "        if isinstance(loss_fn, str):\n",
    "            self.loss_fn = get_loss_metric(loss_fn)\n",
    "        else:\n",
    "            self.loss_fn = loss_fn\n",
    "\n",
    "    def pde(self):\n",
    "        \"\"\"Define the gonvering equation.\"\"\"\n",
    "        u, v, p = self.out_vars\n",
    "        u_x = diff(u, self.x)\n",
    "        u_y = diff(u, self.y)\n",
    "        v_x = diff(v, self.x)\n",
    "        v_y = diff(v, self.y)\n",
    "        p_x = diff(p, self.x)\n",
    "        p_y = diff(p, self.y)\n",
    "        u_xx = diff(u_x, self.x)\n",
    "        u_yy = diff(u_y, self.y)\n",
    "        v_xx = diff(v_x, self.x)\n",
    "        v_yy = diff(v_y, self.y)\n",
    "        momentum_x = u * u_x + v * u_y + p_x - (1 / self.re) * (u_xx + u_yy)\n",
    "        momentum_y = u * v_x + v * v_y + p_y - (1 / self.re) * (v_xx + v_yy)\n",
    "        continuty = u_x + v_y\n",
    "        equations = {\n",
    "            \"momentum_x\": momentum_x,\n",
    "            \"momentum_y\": momentum_y,\n",
    "            \"continuty\": continuty,\n",
    "        }\n",
    "        return equations\n",
    "\n",
    "    def u_func(self):\n",
    "        \"\"\"Define the analytical solution.\"\"\"\n",
    "        u = 1 - sympy.exp(self.l * self.x) * sympy.cos(2 * sympy.pi * self.y)\n",
    "        return u\n",
    "\n",
    "    def v_func(self):\n",
    "        \"\"\"Define the analytical solution.\"\"\"\n",
    "        v = (\n",
    "            self.l\n",
    "            / (2 * sympy.pi)\n",
    "            * sympy.exp(self.l * self.x)\n",
    "            * sympy.sin(2 * sympy.pi * self.y)\n",
    "        )\n",
    "        return v\n",
    "\n",
    "    def p_func(self):\n",
    "        \"\"\"Define the analytical solution.\"\"\"\n",
    "        p = 1 / 2 * (1 - sympy.exp(2 * self.l * self.x))\n",
    "        return p\n",
    "\n",
    "    def bc(self):\n",
    "        \"\"\"Define the boundary condition.\"\"\"\n",
    "        bc_u = self.u - self.u_func()\n",
    "        bc_v = self.v - self.v_func()\n",
    "        bc_p = self.p - self.p_func()\n",
    "        bcs = {\"u\": bc_u, \"v\": bc_v, \"p\": bc_p}\n",
    "        return bcs\n",
    "\n",
    "    def get_loss(self, pde_data, bc_data):\n",
    "        \"\"\"Define the loss function.\"\"\"\n",
    "        pde_res = self.parse_node(self.pde_nodes, inputs=pde_data)\n",
    "        pde_residual = ops.Concat(axis=1)(pde_res)\n",
    "        pde_loss = self.loss_fn(pde_residual, ms_np.zeros_like(pde_residual))\n",
    "        bc_res = self.parse_node(self.bc_nodes, inputs=bc_data)\n",
    "        bc_residual = ops.Concat(axis=1)(bc_res)\n",
    "        bc_loss = self.loss_fn(bc_residual, ms_np.zeros_like(bc_residual))\n",
    "        return pde_loss + bc_loss\n",
    "\n",
    "\n",
    "# Create the problem\n",
    "problem = Kovasznay(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型训练\n",
    "\n",
    "使用MindSpore>= 2.0.0的版本，可以使用函数式编程范式训练神经网络。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(config):\n",
    "    grad_fn = ops.value_and_grad(\n",
    "        problem.get_loss, None, optimizer.parameters, has_aux=False\n",
    "    )\n",
    "\n",
    "    @jit\n",
    "    def train_step(pde_data, bc_data):\n",
    "        loss, grads = grad_fn(pde_data, bc_data)\n",
    "        loss = ops.depend(loss, optimizer(grads))\n",
    "        return loss\n",
    "\n",
    "    def train_epoch(model, dataset, i_epoch):\n",
    "        model.set_train()\n",
    "        n_step = dataset.get_dataset_size()\n",
    "        for i_step, (pde_data, bc_data) in enumerate(dataset):\n",
    "            local_time_beg = time.time()\n",
    "            loss = train_step(pde_data, bc_data)\n",
    "\n",
    "            if i_step % 50 == 0:\n",
    "                print(\n",
    "                    \"\\repoch: {}, loss: {:>f}, time elapsed: {:.1f}ms [{}/{}]\".format(\n",
    "                        i_epoch,\n",
    "                        float(loss),\n",
    "                        (time.time() - local_time_beg) * 1000,\n",
    "                        i_step + 1,\n",
    "                        n_step,\n",
    "                    )\n",
    "                )\n",
    "\n",
    "    for i_epoch in range(config[\"epochs\"]):\n",
    "        train_epoch(model, ds_train, i_epoch)\n",
    "\n",
    "    if config[\"save_ckpt\"]:\n",
    "        save_checkpoint(model, config[\"save_ckpt_path\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0, loss: 0.239163, time elapsed: 9470.9ms [1/125]\n",
      "epoch: 0, loss: 0.087055, time elapsed: 44.7ms [51/125]\n",
      "epoch: 0, loss: 0.086475, time elapsed: 45.2ms [101/125]\n",
      "epoch: 1, loss: 0.085488, time elapsed: 47.1ms [1/125]\n",
      "epoch: 1, loss: 0.087387, time elapsed: 45.5ms [51/125]\n",
      "epoch: 1, loss: 0.083520, time elapsed: 45.2ms [101/125]\n",
      "epoch: 2, loss: 0.083846, time elapsed: 47.5ms [1/125]\n",
      "epoch: 2, loss: 0.082749, time elapsed: 45.1ms [51/125]\n",
      "epoch: 2, loss: 0.081391, time elapsed: 46.2ms [101/125]\n",
      "epoch: 3, loss: 0.081744, time elapsed: 47.2ms [1/125]\n",
      "epoch: 3, loss: 0.080608, time elapsed: 45.8ms [51/125]\n",
      "epoch: 3, loss: 0.082139, time elapsed: 45.1ms [101/125]\n",
      "epoch: 4, loss: 0.080847, time elapsed: 47.6ms [1/125]\n",
      "epoch: 4, loss: 0.083495, time elapsed: 46.0ms [51/125]\n",
      "epoch: 4, loss: 0.083020, time elapsed: 45.3ms [101/125]\n",
      "epoch: 5, loss: 0.079421, time elapsed: 76.9ms [1/125]\n",
      "epoch: 5, loss: 0.062890, time elapsed: 44.6ms [51/125]\n",
      "epoch: 5, loss: 0.018953, time elapsed: 45.2ms [101/125]\n",
      "epoch: 6, loss: 0.012071, time elapsed: 49.6ms [1/125]\n",
      "epoch: 6, loss: 0.007686, time elapsed: 45.5ms [51/125]\n",
      "epoch: 6, loss: 0.006134, time elapsed: 73.7ms [101/125]\n",
      "epoch: 7, loss: 0.005750, time elapsed: 47.2ms [1/125]\n",
      "epoch: 7, loss: 0.004908, time elapsed: 45.7ms [51/125]\n",
      "epoch: 7, loss: 0.003643, time elapsed: 45.6ms [101/125]\n",
      "epoch: 8, loss: 0.002799, time elapsed: 48.2ms [1/125]\n",
      "epoch: 8, loss: 0.002110, time elapsed: 45.5ms [51/125]\n",
      "epoch: 8, loss: 0.001503, time elapsed: 46.6ms [101/125]\n",
      "epoch: 9, loss: 0.001195, time elapsed: 48.0ms [1/125]\n",
      "epoch: 9, loss: 0.000700, time elapsed: 45.5ms [51/125]\n",
      "epoch: 9, loss: 0.000478, time elapsed: 47.1ms [101/125]\n",
      "epoch: 10, loss: 0.000392, time elapsed: 71.8ms [1/125]\n",
      "epoch: 10, loss: 0.000315, time elapsed: 45.8ms [51/125]\n",
      "epoch: 10, loss: 0.000236, time elapsed: 50.4ms [101/125]\n",
      "epoch: 11, loss: 0.000218, time elapsed: 48.4ms [1/125]\n",
      "epoch: 11, loss: 0.000184, time elapsed: 46.4ms [51/125]\n",
      "epoch: 11, loss: 0.000171, time elapsed: 54.9ms [101/125]\n",
      "epoch: 12, loss: 0.000145, time elapsed: 47.7ms [1/125]\n",
      "epoch: 12, loss: 0.000144, time elapsed: 46.9ms [51/125]\n",
      "epoch: 12, loss: 0.000126, time elapsed: 60.5ms [101/125]\n",
      "epoch: 13, loss: 0.000111, time elapsed: 48.6ms [1/125]\n",
      "epoch: 13, loss: 0.000109, time elapsed: 46.7ms [51/125]\n",
      "epoch: 13, loss: 0.000090, time elapsed: 45.3ms [101/125]\n",
      "epoch: 14, loss: 0.000094, time elapsed: 48.0ms [1/125]\n",
      "epoch: 14, loss: 0.000079, time elapsed: 46.1ms [51/125]\n",
      "epoch: 14, loss: 0.000070, time elapsed: 47.6ms [101/125]\n",
      "epoch: 15, loss: 0.000193, time elapsed: 53.1ms [1/125]\n",
      "epoch: 15, loss: 0.000066, time elapsed: 47.7ms [51/125]\n",
      "epoch: 15, loss: 0.000118, time elapsed: 49.3ms [101/125]\n",
      "epoch: 16, loss: 0.000074, time elapsed: 48.7ms [1/125]\n",
      "epoch: 16, loss: 0.000054, time elapsed: 85.8ms [51/125]\n",
      "epoch: 16, loss: 0.000065, time elapsed: 97.4ms [101/125]\n",
      "epoch: 17, loss: 0.000050, time elapsed: 101.0ms [1/125]\n",
      "epoch: 17, loss: 0.000056, time elapsed: 86.3ms [51/125]\n",
      "epoch: 17, loss: 0.000045, time elapsed: 46.8ms [101/125]\n",
      "epoch: 18, loss: 0.000043, time elapsed: 107.0ms [1/125]\n",
      "epoch: 18, loss: 0.000043, time elapsed: 46.4ms [51/125]\n",
      "epoch: 18, loss: 0.000050, time elapsed: 45.9ms [101/125]\n",
      "epoch: 19, loss: 0.000038, time elapsed: 95.2ms [1/125]\n",
      "epoch: 19, loss: 0.000051, time elapsed: 76.3ms [51/125]\n",
      "epoch: 19, loss: 0.000044, time elapsed: 44.7ms [101/125]\n",
      "End-to-End total time: 148.45410752296448 s\n"
     ]
    }
   ],
   "source": [
    "time_beg = time.time()\n",
    "train(config)\n",
    "print(\"End-to-End total time: {} s\".format(time.time() - time_beg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from src import visual, calculate_l2_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型预测可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x288 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visual(model, config, resolution=config[\"visual_resolution\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "u: 1 - exp(-1.81009812001397*x)*cos(2*pi*y)\n",
      "    Item numbers of current derivative formula nodes: 2\n",
      "v: -0.905049060006983*exp(-1.81009812001397*x)*sin(2*pi*y)/pi\n",
      "    Item numbers of current derivative formula nodes: 1\n",
      "p: 0.5 - 0.5*exp(-3.62019624002793*x)\n",
      "    Item numbers of current derivative formula nodes: 2\n",
      "Relative L2 error on domain: 0.003131713718175888\n",
      "Relative L2 error on boundary: 0.0069109550677239895\n"
     ]
    }
   ],
   "source": [
    "n_samps = 10000  # Number of test samples\n",
    "ds_test = create_dataset(config, n_samps)\n",
    "calculate_l2_error(problem, model, ds_test)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mulnet",
   "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.8.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}