[![binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gl/rubendibattista%2Fjosiepy/master/?filepath=examples%2F002_Advection.ipynb) # Implementing a solver for the advection equation We're going to write all the necessary objects to solve the following equation: ```math \partial_t \varphi + \mathbf{u} \cdot \nabla \varphi = 0 ``` That, compared to our generalized model: ```math \partial_t \mathbf{q} + \nabla \cdot \left(\underline{\underline{\mathbf{F}}}(\mathbf{q}) + \underline{\underline{\underline{\underline{D(\mathbf{q})}}}} \cdot \nabla \mathbf{q} \right) + \underline{\underline{\underline{\mathbf{B}(\mathbf{q})}}} \cdot \nabla\mathbf{q} = \mathbf{s}(\mathbf{q}) ``` Gives `$ \mathbf{q} = \left\{\varphi\right\} $` `$ \mathbf{F} = \underline{\underline{\mathbf{0}}} $`, `$ \mathbf{D} = \underline{\underline{\underline{\underline{\mathbf{0}}}}} $` So our problem needs just to provide `$ \mathbf{B} $`. ```math B_{pqr} = u_r ``` ## `State` ```python from josie.state import State from josie.fields import Fields class AdvectionFields(Fields): phi = 0 class AdvectionState(State): fields = AdvectionFields ``` ## `Problem` We just need to implement the `$ \mathbf{B}(\mathbf{q}) $` operator ```python from josie.problem import Problem Problem?? ``` ```python from josie.mesh.cellset import CellSet, MeshCellSet class AdvectionProblem(Problem): V = np.array([1, 0]) DIMENSIONALITY = 2 ## 2D def B(self, cells: CellSet): values: AdvectionState = cells.values nx, ny, num_fields = values.shape fields = values.fields B = np.zeros((nx, ny, num_fields, num_fields, self.DIMENSIONALITY)) B[..., fields.phi, fields.phi, : ] = self.V return B ``` ## `Scheme` ![cell_scheme](data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   inkscape:version="1.0rc1 (09960d6, 2020-04-09)"
   sodipodi:docname="cell_scheme.svg"
   viewBox="0 0 197.33333 144"
   height="144"
   width="197.33333"
   xml:space="preserve"
   id="svg1040"
   version="1.1"><metadata
     id="metadata1046"><rdf:RDF><cc:Work
         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
     id="defs1044" /><sodipodi:namedview
     inkscape:current-layer="g1048"
     inkscape:window-maximized="0"
     inkscape:window-y="23"
     inkscape:window-x="0"
     inkscape:cy="72"
     inkscape:cx="98.666664"
     inkscape:zoom="3.6081082"
     showgrid="false"
     id="namedview1042"
     inkscape:window-height="953"
     inkscape:window-width="1680"
     inkscape:pageshadow="2"
     inkscape:pageopacity="0"
     guidetolerance="10"
     gridtolerance="10"
     objecttolerance="10"
     borderopacity="1"
     bordercolor="#666666"
     pagecolor="#ffffff" /><g
     transform="matrix(1.3333333,0,0,-1.3333333,0,144)"
     inkscape:label="ink_ext_XXXXXX"
     inkscape:groupmode="layer"
     id="g1048"><g
       transform="scale(0.1)"
       id="g1050"><path
         inkscape:connector-curvature="0"
         id="path1052"
         style="fill:none;stroke:#000000;stroke-width:8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="m 803.98,645.738 h 640 V 5.73828 l -480,159.99972 -160,480" /><path
         inkscape:connector-curvature="0"
         id="path1054"
         style="fill:none;stroke:#000000;stroke-width:8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="M 803.98,644.02 H 3.98047 L 163.98,4.01953 963.98,164.02" /><path
         inkscape:connector-curvature="0"
         id="path1056"
         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:none"
         d="m 490.551,372.77 c 0,24.031 -36.02,24.031 -36.02,0 0,-23.981 36.02,-23.981 36.02,0 z" /><path
         inkscape:connector-curvature="0"
         id="path1058"
         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:none"
         d="m 1209.14,404.449 c 0,23.992 -36.02,23.992 -36.02,0 0,-24.019 36.02,-24.019 36.02,0 z" /><path
         inkscape:connector-curvature="0"
         id="path1060"
         style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="M 680.199,339.648 1089.49,492.191" /><path
         inkscape:connector-curvature="0"
         id="path1062"
         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:none"
         d="m 1089.49,492.191 -73.75,-2.621 16.29,-43.672 z" /><path
         inkscape:connector-curvature="0"
         id="path1064"
         style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="m 1089.49,492.191 -73.75,-2.621 16.29,-43.672 z" /><g
         transform="scale(10)"
         id="g1066"><text
           id="text1070"
           style="font-variant:normal;font-size:9.9626px;font-family:f-0;-inkscape-font-specification:f-0-0;writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
           transform="matrix(1,0,0,-1,92.9984,48.6852)"><tspan
             id="tspan1068"
             y="0"
             x="0">ˆ</tspan></text><text
           id="text1074"
           style="font-variant:normal;font-size:9.9626px;font-family:f-1;-inkscape-font-specification:f-1-0;writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
           transform="matrix(1,0,0,-1,92.306212,48.546919)"><tspan
             id="tspan1072"
             y="0"
             x="0">n</tspan></text></g><path
         inkscape:connector-curvature="0"
         id="path1076"
         style="fill:none;stroke:#000000;stroke-width:20;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="m 803.98,644.02 160,-480" /><g
         transform="scale(10)"
         id="g1078"><text
           id="text1082"
           style="font-variant:normal;font-size:9.9626px;font-family:f-2;-inkscape-font-specification:f-2-0;writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
           transform="matrix(1,0,0,-1,95.6645,30.6879)"><tspan
             id="tspan1080"
             y="0"
             x="0">S</tspan></text><text
           id="text1086"
           style="font-variant:normal;font-size:6.9738px;font-family:f-3;-inkscape-font-specification:f-3-0;writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
           transform="matrix(1,0,0,-1,101.77348,29.19376)"><tspan
             id="tspan1084"
             y="0"
             x="0">f</tspan></text></g><path
         inkscape:connector-curvature="0"
         id="path1088"
         style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="M 474.219,372.77 365.352,890.898" /><path
         inkscape:connector-curvature="0"
         id="path1090"
         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:none"
         d="m 474.219,372.77 8.402,73.32 -45.633,-9.61 z" /><path
         inkscape:connector-curvature="0"
         id="path1092"
         style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="m 474.219,372.77 8.402,73.32 -45.633,-9.61 z" /><g
         transform="scale(10)"
         id="g1094"><text
           id="text1098"
           style="font-variant:normal;font-size:9.9626px;font-family:f-4;-inkscape-font-specification:f-4-0;writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
           transform="matrix(1,0,0,-1,24.1879,90.0746)"><tspan
             id="tspan1096"
             sodipodi:role="line"
             y="0"
             x="0 5.2303648 10.46073 15.691095 20.921459">value</tspan></text></g><path
         inkscape:connector-curvature="0"
         id="path1100"
         style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="m 1191.13,404.449 -32.65,540.672" /><path
         inkscape:connector-curvature="0"
         id="path1102"
         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:none"
         d="m 1191.13,404.449 19.07,71.289 -46.57,-2.808 z" /><path
         inkscape:connector-curvature="0"
         id="path1104"
         style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="m 1191.13,404.449 19.07,71.289 -46.57,-2.808 z" /><g
         transform="scale(10)"
         id="g1106"><text
           id="text1110"
           style="font-variant:normal;font-size:9.9626px;font-family:f-4;-inkscape-font-specification:f-4-0;writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
           transform="matrix(1,0,0,-1,92.1723,100.912)"><tspan
             id="tspan1108"
             sodipodi:role="line"
             y="0"
             x="0 5.2303648 10.46073 15.691095 20.921459">neigh</tspan></text></g><path
         inkscape:connector-curvature="0"
         id="path1112"
         style="fill:none;stroke:#000000;stroke-width:3.98;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
         d="m 1189.53,1011.09 h 31.37" /><g
         transform="scale(10)"
         id="g1114"><text
           id="text1118"
           style="font-variant:normal;font-size:9.9626px;font-family:f-4;-inkscape-font-specification:f-4-0;writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
           transform="matrix(1,0,0,-1,122.091,100.912)"><tspan
             id="tspan1116"
             sodipodi:role="line"
             y="0"
             x="0 5.2303648 10.46073 15.691095 20.921459">value</tspan></text></g></g></g></svg>
) We just need to implement the ```math \mathbf{G}_{\frac{1}{2}}(\mathbf{q}) = \left| \mathbf{q}\hat{\mathbf{n}} \right|_f S_f \Rightarrow \left| \varphi \hat{\mathbf{n}}\right|_f S_f ``` ```python from josie.scheme.nonconservative import NonConservativeScheme NonConservativeScheme?? ``` ```python class Upwind(NonConservativeScheme): def G(self, cells: MeshCellSet, neighs: CellSet): V = self.problem.V # Get the normal velocities (that are equal everywhere) per each cell Vn = np.einsum("k,...kl->...l", V, neighs.normals[..., np.newaxis]) values_face = np.zeros_like(cells.values) # We use the cell value where Vn > 0 np.copyto(values_face, cells.values, where=(Vn>0)) # We use the neighbour value otherwise np.copyto(values_face, neighs.values, where=(Vn<=0)) # Multiply by the normal valuesn_face = np.einsum("...i,...j->...ij", values_face, neighs.normals) # Multiply by the surface G = valuesn_face * neighs.surfaces[..., np.newaxis, np.newaxis] return G ``` ## `Mesh` We generated a 1D mesh ```python from josie.boundary import Line left = Line([0, 0], [0, 1]) bottom = Line([0, 0], [1, 0]) right = Line([1, 0], [1, 1]) top = Line([0, 1], [1, 1]) ``` We apply periodic boundary condition along the x-axis (no BC on y-axis since it's a 1D simulation) ```python from josie.bc import make_periodic, Direction left, right = make_periodic(left, right, Direction.X) top.bc = None bottom.bc = None print(left, right, top, bottom) ``` ```python from josie.mesh import Mesh from josie.mesh.cell import SimpleCell mesh = Mesh(left, bottom, right, top, SimpleCell) mesh.interpolate(300, 1) mesh.generate() ``` ## `Solver` Let's assemble our scheme, that still needs the time scheme, and a CFL method ```python from josie.general.schemes.time import ExplicitEuler class AdvectionScheme(Upwind, ExplicitEuler): def CFL( self, cells: MeshCellSet, CFL_value: float, ) -> float: U_abs = np.linalg.norm(self.problem.V) dx = np.min(cells.surfaces) return CFL_value * dx / U_abs scheme = AdvectionScheme(AdvectionProblem()) ``` ```python from josie.solver import Solver solver = Solver(mesh, AdvectionState, scheme) ``` We need now to define an initialization function to initialize the domain ```python def init_fun(cells: MeshCellSet): xc = cells.centroids[..., 0] xc_r = np.where(xc >= 0.5) xc_l = np.where(xc < 0.5) cells.values[xc_r[0], xc_r[1], ...] = 1 cells.values[xc_l[0], xc_l[1], ...] = 0 ``` ### Run the simulation Let's initialize the solver state ```python solver.init(init_fun) # Plotting stuff import matplotlib.pyplot as plt import copy from matplotlib.animation import ArtistAnimation solution = [] t = 0 final_time = 1 CFL = 0.5 ``` Let's iterate in time choosing a time-based writing strategy (save every `$ 0.01s $`) to memory ```python from josie.io.write.strategy import TimeStrategy from josie.io.write.writer import MemoryWriter strategy = TimeStrategy(dt_save=0.01) writer = MemoryWriter(strategy, solver, final_time, CFL) writer.solve() ``` ```python fig, ax = plt.subplots() ims = [] for solution in writer.data: cells = solution.mesh.cells x = cells.centroids[..., 0] x = x.reshape(x.size) phi = cells.values[..., AdvectionFields.phi] (im,) = ax.plot(x, phi, 'ko-') ims.append([im]) ani = ArtistAnimation(fig, ims, interval=50) ``` ![png](data:image/png;base64,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 )