diff --git a/doc/notebooks/10_tutorial_conservative_allen_cahn_two_phase.ipynb b/doc/notebooks/10_tutorial_conservative_allen_cahn_two_phase.ipynb
index 155729876de0bfd9dd9e2b3f74f02bf4150e87cf..40c17cc7b0ff82bc21f1b3c61fff13fafa70b701 100644
--- a/doc/notebooks/10_tutorial_conservative_allen_cahn_two_phase.ipynb
+++ b/doc/notebooks/10_tutorial_conservative_allen_cahn_two_phase.ipynb
@@ -20,10 +20,8 @@
     "from pystencils.boundaries import BoundaryHandling\n",
     "\n",
     "from lbmpy.phasefield_allen_cahn.contact_angle import ContactAngle\n",
-    "from lbmpy.phasefield_allen_cahn.force_model import MultiphaseForceModel, CentralMomentMultiphaseForceModel\n",
     "from lbmpy.phasefield_allen_cahn.kernel_equations import *\n",
-    "from lbmpy.phasefield_allen_cahn.parameter_calculation import calculate_parameters_rti\n",
-    "\n",
+    "from lbmpy.phasefield_allen_cahn.parameter_calculation import calculate_parameters_rti, AllenCahnParameters\n",
     "from lbmpy.advanced_streaming import LBMPeriodicityHandling\n",
     "from lbmpy.boundaries import NoSlip, LatticeBoltzmannBoundaryHandling"
    ]
@@ -133,42 +131,101 @@
     "\n",
     "# reference time\n",
     "reference_time = 4000\n",
-    "# density of the heavier fluid\n",
-    "rho_H = 1.0\n",
     "\n",
     "# calculate the parameters for the RTI\n",
     "parameters = calculate_parameters_rti(reference_length=L0,\n",
     "                                      reference_time=reference_time,\n",
-    "                                      density_heavy=rho_H,\n",
+    "                                      density_heavy=1.0,\n",
     "                                      capillary_number=0.44,\n",
     "                                      reynolds_number=3000,\n",
     "                                      atwood_number=0.998,\n",
     "                                      peclet_number=1000,\n",
     "                                      density_ratio=1000,\n",
-    "                                      viscosity_ratio=100)\n",
-    "# get the parameters\n",
-    "rho_L = parameters.get(\"density_light\")\n",
-    "\n",
-    "mu_H = parameters.get(\"dynamic_viscosity_heavy\")\n",
-    "mu_L = parameters.get(\"dynamic_viscosity_light\")\n",
-    "\n",
-    "tau_H = parameters.get(\"relaxation_time_heavy\")\n",
-    "tau_L = parameters.get(\"relaxation_time_light\")\n",
-    "\n",
-    "sigma = parameters.get(\"surface_tension\")\n",
-    "M = parameters.get(\"mobility\")\n",
-    "gravitational_acceleration = parameters.get(\"gravitational_acceleration\")\n",
-    "\n",
-    "\n",
-    "drho3 = (rho_H - rho_L)/3\n",
-    "# interface thickness\n",
-    "W = 5\n",
-    "# coeffcient related to surface tension\n",
-    "beta = 12.0 * (sigma/W)\n",
-    "# coeffcient related to surface tension\n",
-    "kappa = 1.5 * sigma*W\n",
-    "# relaxation rate allen cahn (h)\n",
-    "w_c = 1.0/(0.5 + (3.0 * M))"
+    "                                      viscosity_ratio=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This function returns a `AllenCahnParameters` class. It is struct like class holding all parameters for the conservative Allen Cahn model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <table style=\"border:none; width: 100%\">\n",
+       "            <tr style=\"border:none\">\n",
+       "                <th style=\"border:none\" >Name</th>\n",
+       "                <th style=\"border:none\" >SymPy Symbol </th>\n",
+       "                <th style=\"border:none\" >Value</th>\n",
+       "            </tr>\n",
+       "            <tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Density heavy phase</td>\n",
+       "                            <td style=\"border:none\">$\\rho_{H}$</td>\n",
+       "                            <td style=\"border:none\">$1.0$</td>\n",
+       "                         </tr>\n",
+       "<tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Density light phase</td>\n",
+       "                            <td style=\"border:none\">$\\rho_{L}$</td>\n",
+       "                            <td style=\"border:none\">$0.001$</td>\n",
+       "                         </tr>\n",
+       "<tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Relaxation time heavy phase</td>\n",
+       "                            <td style=\"border:none\">$\\tau_{H}$</td>\n",
+       "                            <td style=\"border:none\">$0.0164004086170318$</td>\n",
+       "                         </tr>\n",
+       "<tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Relaxation time light phase</td>\n",
+       "                            <td style=\"border:none\">$\\tau_{L}$</td>\n",
+       "                            <td style=\"border:none\">$0.164004086170318$</td>\n",
+       "                         </tr>\n",
+       "<tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Relaxation rate Allen Cahn LB</td>\n",
+       "                            <td style=\"border:none\">$\\omega_{\\phi}$</td>\n",
+       "                            <td style=\"border:none\">$1.82082623441035$</td>\n",
+       "                         </tr>\n",
+       "<tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Gravitational acceleration</td>\n",
+       "                            <td style=\"border:none\">$F_{g}$</td>\n",
+       "                            <td style=\"border:none\">$-1.60320641282565 \\cdot 10^{-5}$</td>\n",
+       "                         </tr>\n",
+       "<tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Interface thickness</td>\n",
+       "                            <td style=\"border:none\">$W$</td>\n",
+       "                            <td style=\"border:none\">$5$</td>\n",
+       "                         </tr>\n",
+       "<tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Mobility</td>\n",
+       "                            <td style=\"border:none\">$M_{m}$</td>\n",
+       "                            <td style=\"border:none\">$0.0164004086170318$</td>\n",
+       "                         </tr>\n",
+       "<tr style=\"border:none\">\n",
+       "                            <td style=\"border:none\">Surface tension</td>\n",
+       "                            <td style=\"border:none\">$\\sigma$</td>\n",
+       "                            <td style=\"border:none\">$0.000795967692961681$</td>\n",
+       "                         </tr>\n",
+       "\n",
+       "        </table>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<lbmpy.phasefield_allen_cahn.parameter_calculation.AllenCahnParameters at 0x1077532b0>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "parameters"
    ]
   },
   {
@@ -182,7 +239,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -220,20 +277,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# relaxation time and rate\n",
-    "tau = 0.5 + tau_L + (C.center) * (tau_H - tau_L)\n",
-    "s8 = 1/(tau)\n",
+    "rho_L = parameters.symbolic_density_light\n",
+    "rho_H = parameters.symbolic_density_heavy\n",
+    "density = rho_L + C.center * (rho_H - rho_L)\n",
     "\n",
-    "# density for the whole domain\n",
-    "rho = rho_L + (C.center) * (rho_H - rho_L)\n",
-    "\n",
-    "# body force\n",
     "body_force = [0, 0, 0]\n",
-    "body_force[1] = gravitational_acceleration * rho"
+    "body_force[1] = parameters.symbolic_gravitational_acceleration * density"
    ]
   },
   {
@@ -247,12 +300,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For both LB steps, a weighted orthogonal MRT (WMRT) method is used. It is also possible to change the method to a simpler SRT scheme or a more complicated CLBM scheme. The CLBM scheme can be obtained by commenting in the python snippets in the notebook cells below. Note here that the hydrodynamic LB step is formulated as an incompressible velocity-based LBM. Thus, the velocity terms can not be removed from the equilibrium in the central moment space."
+    "For both LB steps, a weighted orthogonal MRT (WMRT) method is used. It is also possible to change the method to a simpler SRT scheme or a more complicated CLBM scheme. The CLBM scheme can be obtained with `Method.CENTRAL_MOMENT`. Note here that the hydrodynamic LB step is formulated as an incompressible velocity-based LBM. Thus, the velocity terms can not be removed from the equilibrium in the central moment space."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -273,12 +326,12 @@
        "<tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$x$</td>\n",
        "                            <td style=\"border:none\">$\\rho u_{0}$</td>\n",
-       "                            <td style=\"border:none\">$1.8208262344103532$</td>\n",
+       "                            <td style=\"border:none\">$\\omega_{\\phi}$</td>\n",
        "                         </tr>\n",
        "<tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$y$</td>\n",
        "                            <td style=\"border:none\">$\\rho u_{1}$</td>\n",
-       "                            <td style=\"border:none\">$1.8208262344103532$</td>\n",
+       "                            <td style=\"border:none\">$\\omega_{\\phi}$</td>\n",
        "                         </tr>\n",
        "<tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$x^{2} - y^{2}$</td>\n",
@@ -315,31 +368,30 @@
        "        "
       ],
       "text/plain": [
-       "<lbmpy.methods.momentbased.momentbasedmethod.MomentBasedLbMethod at 0x12a4075e0>"
+       "<lbmpy.methods.momentbased.momentbasedmethod.MomentBasedLbMethod at 0x15359b8e0>"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "w_c = parameters.symbolic_omega_phi\n",
+    "\n",
     "config_phase = LBMConfig(stencil=stencil_phase, method=Method.MRT, compressible=True,\n",
-    "                         weighted=True, relaxation_rates=[1, 1, 1, 1, 1])\n",
+    "                         force=sp.symbols(\"F_:2\"), velocity_input=u,\n",
+    "                         weighted=True, relaxation_rates=[0, w_c, w_c, 1, 1, 1, 1, 1, 1],\n",
+    "                         output={'density': C_tmp}, kernel_type='stream_pull_collide')\n",
     "\n",
     "method_phase = create_lb_method(lbm_config=config_phase)\n",
-    "method_phase.set_first_moment_relaxation_rate(w_c)\n",
-    "\n",
-    "# config_phase = LBMConfig(stencil=stencil_phase, method=Method.CENTRAL_MOMENT, compressible=True,\n",
-    "#                          weighted=True, relaxation_rates=[0, w_c, 1, 1, 1], equilibrium_order=4)\n",
     "\n",
-    "# method_phase = create_lb_method(lbm_config=config_phase)\n",
     "method_phase"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -355,27 +407,27 @@
        "            <tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$1$</td>\n",
        "                            <td style=\"border:none\">$\\rho$</td>\n",
-       "                            <td style=\"border:none\">$0$</td>\n",
+       "                            <td style=\"border:none\">$0.0$</td>\n",
        "                         </tr>\n",
        "<tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$x$</td>\n",
        "                            <td style=\"border:none\">$u_{0}$</td>\n",
-       "                            <td style=\"border:none\">$0$</td>\n",
+       "                            <td style=\"border:none\">$0.0$</td>\n",
        "                         </tr>\n",
        "<tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$y$</td>\n",
        "                            <td style=\"border:none\">$u_{1}$</td>\n",
-       "                            <td style=\"border:none\">$0$</td>\n",
+       "                            <td style=\"border:none\">$0.0$</td>\n",
        "                         </tr>\n",
        "<tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$x^{2} - y^{2}$</td>\n",
        "                            <td style=\"border:none\">$u_{0}^{2} - u_{1}^{2}$</td>\n",
-       "                            <td style=\"border:none\">$\\frac{1}{0.664004086170318 - 0.147603677553286 {{C}_{(0,0)}}}$</td>\n",
+       "                            <td style=\"border:none\">$\\frac{2}{2 {C}_{(0,0)} \\left(\\tau_{H} - \\tau_{L}\\right) + 2 \\tau_{L} + 1}$</td>\n",
        "                         </tr>\n",
        "<tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$x y$</td>\n",
        "                            <td style=\"border:none\">$u_{0} u_{1}$</td>\n",
-       "                            <td style=\"border:none\">$\\frac{1}{0.664004086170318 - 0.147603677553286 {{C}_{(0,0)}}}$</td>\n",
+       "                            <td style=\"border:none\">$\\frac{2}{2 {C}_{(0,0)} \\left(\\tau_{H} - \\tau_{L}\\right) + 2 \\tau_{L} + 1}$</td>\n",
        "                         </tr>\n",
        "<tr style=\"border:none\">\n",
        "                            <td style=\"border:none\">$3 x^{2} + 3 y^{2} - 2$</td>\n",
@@ -402,26 +454,23 @@
        "        "
       ],
       "text/plain": [
-       "<lbmpy.methods.momentbased.momentbasedmethod.MomentBasedLbMethod at 0x11ff35c10>"
+       "<lbmpy.methods.momentbased.momentbasedmethod.MomentBasedLbMethod at 0x1537fa070>"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "omega = parameters.omega(C)\n",
     "config_hydro = LBMConfig(stencil=stencil_hydro, method=Method.MRT, compressible=False,\n",
-    "                         weighted=True, relaxation_rates=[s8, 1, 1, 1])\n",
+    "                         weighted=True, relaxation_rates=[omega, 1, 1, 1],\n",
+    "                         force=sp.symbols(\"F_:2\"),\n",
+    "                         output={'velocity': u}, kernel_type='collide_stream_push')\n",
     "\n",
     "method_hydro = create_lb_method(lbm_config=config_hydro)\n",
     "\n",
-    "\n",
-    "# config_hydro = LBMConfig(stencil=stencil_hydro, method=Method.CENTRAL_MOMENT, compressible=False,\n",
-    "#                          weighted=True, relaxation_rates=[s8, 1, 1], equilibrium_order=4)\n",
-    "\n",
-    "# method_hydro = create_lb_method(lbm_config=config_hydro)\n",
-    "\n",
     "method_hydro"
    ]
   },
@@ -441,12 +490,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
-    "h_updates = initializer_kernel_phase_field_lb(h, C, u, method_phase, W)\n",
-    "g_updates = initializer_kernel_hydro_lb(g, u, method_hydro)\n",
+    "h_updates = initializer_kernel_phase_field_lb(method_phase, C, u, h, parameters)\n",
+    "g_updates = initializer_kernel_hydro_lb(method_hydro, 1, u, g)\n",
     "\n",
     "h_init = ps.create_kernel(h_updates, target=dh.default_target, cpu_openmp=True).compile()\n",
     "g_init = ps.create_kernel(g_updates, target=dh.default_target, cpu_openmp=True).compile()"
@@ -461,7 +510,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -479,29 +528,29 @@
     "\n",
     "        y -= 2 * L0\n",
     "        tmp = 0.1 * Nx * np.cos((2 * np.pi * x) / Nx)\n",
-    "        init_values = 0.5 + 0.5 * np.tanh((y - tmp) / (W / 2))\n",
+    "        init_values = 0.5 + 0.5 * np.tanh((y - tmp) / (parameters.interface_thickness / 2))\n",
     "        block[\"C\"][:, :] = init_values\n",
     "        block[\"C_tmp\"][:, :] = init_values\n",
     "        \n",
     "    if gpu:\n",
     "        dh.all_to_gpu()            \n",
     "    \n",
-    "    dh.run_kernel(h_init)\n",
+    "    dh.run_kernel(h_init, **parameters.symbolic_to_numeric_map)\n",
     "    dh.run_kernel(g_init)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x12a9da5e0>"
+       "<matplotlib.image.AxesImage at 0x1539477c0>"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -569,24 +618,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
-    "force_h = [f / 3 for f in interface_tracking_force(C, stencil_phase, W)]\n",
-    "force_g = hydrodynamic_force(g, C, method_hydro, tau, rho_H, rho_L, kappa, beta, body_force)\n",
-    "\n",
-    "\n",
-    "if isinstance(method_phase, CentralMomentBasedLbMethod):\n",
-    "    force_model_h = CentralMomentMultiphaseForceModel(force=force_h)\n",
-    "else:\n",
-    "    force_model_h = MultiphaseForceModel(force=force_h)\n",
-    "\n",
-    "\n",
-    "if isinstance(method_hydro, CentralMomentBasedLbMethod):\n",
-    "    force_model_g = CentralMomentMultiphaseForceModel(force=force_g, rho=rho)\n",
-    "else:\n",
-    "    force_model_g = MultiphaseForceModel(force=force_g, rho=rho)"
+    "force_h = interface_tracking_force(C, stencil_phase, parameters)\n",
+    "hydro_force = hydrodynamic_force(g, C, method_hydro, parameters, body_force)"
    ]
   },
   {
@@ -610,22 +647,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
-    "allen_cahn_lb = get_collision_assignments_phase(lb_method=method_phase,\n",
-    "                                                velocity_input=u,\n",
-    "                                                output={'density': C_tmp},\n",
-    "                                                force_model=force_model_h,\n",
-    "                                                symbolic_fields={\"symbolic_field\": h,\n",
-    "                                                                 \"symbolic_temporary_field\": h_tmp},\n",
-    "                                                kernel_type='stream_pull_collide')\n",
+    "lbm_optimisation = LBMOptimisation(symbolic_field=h, symbolic_temporary_field=h_tmp)\n",
+    "allen_cahn_update_rule = create_lb_update_rule(lbm_config=config_phase,\n",
+    "                                               lbm_optimisation=lbm_optimisation)\n",
     "\n",
-    "# allen_cahn_lb = sympy_cse(allen_cahn_lb)\n",
+    "allen_cahn_update_rule = add_interface_tracking_force(allen_cahn_update_rule, force_h)\n",
     "\n",
-    "ast_allen_cahn_lb = ps.create_kernel(allen_cahn_lb, target=dh.default_target, cpu_openmp=True)\n",
-    "kernel_allen_cahn_lb = ast_allen_cahn_lb.compile()"
+    "ast_kernel = ps.create_kernel(allen_cahn_update_rule, target=dh.default_target, cpu_openmp=True)\n",
+    "kernel_allen_cahn_lb = ast_kernel.compile()"
    ]
   },
   {
@@ -643,25 +676,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {
     "scrolled": false
    },
    "outputs": [],
    "source": [
-    "hydro_lb_update_rule = get_collision_assignments_hydro(lb_method=method_hydro,\n",
-    "                                                       density=rho,\n",
-    "                                                       velocity_input=u,\n",
-    "                                                       force_model=force_model_g,\n",
-    "                                                       sub_iterations=2,\n",
-    "                                                       symbolic_fields={\"symbolic_field\": g,\n",
-    "                                                                        \"symbolic_temporary_field\": g_tmp},\n",
-    "                                                       kernel_type='collide_stream_push')\n",
+    "force_Assignments = hydrodynamic_force_assignments(g, u, C, method_hydro, parameters, body_force)\n",
     "\n",
-    "# hydro_lb_update_rule = sympy_cse(hydro_lb_update_rule)\n",
+    "lbm_optimisation = LBMOptimisation(symbolic_field=g, symbolic_temporary_field=g_tmp)\n",
+    "hydro_lb_update_rule = create_lb_update_rule(lbm_config=config_hydro,\n",
+    "                                             lbm_optimisation=lbm_optimisation)\n",
     "\n",
-    "ast_hydro_lb = ps.create_kernel(hydro_lb_update_rule, target=dh.default_target, cpu_openmp=True)\n",
-    "kernel_hydro_lb = ast_hydro_lb.compile()"
+    "hydro_lb_update_rule = add_hydrodynamic_force(hydro_lb_update_rule, force_Assignments, C, g, parameters)\n",
+    "\n",
+    "ast_kernel = ps.create_kernel(hydro_lb_update_rule, target=dh.default_target, cpu_openmp=True)\n",
+    "kernel_hydro_lb = ast_kernel.compile()"
    ]
   },
   {
@@ -680,7 +710,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -703,7 +733,7 @@
     "                                            streaming_pattern='push')\n",
     "\n",
     "contact_angle = BoundaryHandling(dh, C.name, stencil_hydro, target=dh.default_target)\n",
-    "contact = ContactAngle(90, W)\n",
+    "contact = ContactAngle(90, parameters.interface_thickness)\n",
     "\n",
     "wall = NoSlip()\n",
     "if dimensions == 2:\n",
@@ -740,7 +770,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -749,7 +779,7 @@
     "    # Solve the interface tracking LB step with boundary conditions\n",
     "    periodic_BC_h()\n",
     "    bh_allen_cahn()    \n",
-    "    dh.run_kernel(kernel_allen_cahn_lb)\n",
+    "    dh.run_kernel(kernel_allen_cahn_lb, **parameters.symbolic_to_numeric_map)\n",
     "    dh.swap(\"C\", \"C_tmp\")\n",
     "    \n",
     "    # apply the three phase-phase contact angle\n",
@@ -758,7 +788,7 @@
     "    periodic_BC_C()\n",
     "    \n",
     "    # solve the hydro LB step with boundary conditions\n",
-    "    dh.run_kernel(kernel_hydro_lb)\n",
+    "    dh.run_kernel(kernel_hydro_lb, **parameters.symbolic_to_numeric_map)\n",
     "    periodic_BC_g()\n",
     "    bh_hydro()\n",
     "\n",
@@ -770,7 +800,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "metadata": {
     "scrolled": false
    },
@@ -779,7 +809,7 @@
      "data": {
       "text/html": [
        "<video controls width=\"80%\">\n",
-       " <source src=\"data:video/x-m4v;base64,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\" type=\"video/mp4\">\n",
+       " <source src=\"data:video/x-m4v;base64,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\" type=\"video/mp4\">\n",
        " Your browser does not support the video tag.\n",
        "</video>"
       ],
@@ -787,7 +817,7 @@
        "<IPython.core.display.HTML object>"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -840,7 +870,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.9.9"
   }
  },
  "nbformat": 4,
diff --git a/lbmpy/macroscopic_value_kernels.py b/lbmpy/macroscopic_value_kernels.py
index 4ec4f31ae4e44f0468ec58a191ea9843c8072a97..08bc051c44fee9ac7fad15b34b7ff3183f48f5f0 100644
--- a/lbmpy/macroscopic_value_kernels.py
+++ b/lbmpy/macroscopic_value_kernels.py
@@ -23,6 +23,12 @@ def pdf_initialization_assignments(lb_method, density, velocity, pdfs,
         raise ValueError("Invalid value of pdfs: A PDF field reference is required to derive "
                          + f"initialization assignments for streaming pattern {streaming_pattern}.")
 
+    if isinstance(density, Field):
+        density = density.center
+
+    if isinstance(velocity, Field):
+        velocity = velocity.center_vector
+
     cqc = lb_method.conserved_quantity_computation
     inp_eqs = cqc.equilibrium_input_equations_from_init_values(density, velocity, force_substitution=False)
     setter_eqs = lb_method.get_equilibrium(conserved_quantity_equations=inp_eqs)
diff --git a/lbmpy/phasefield_allen_cahn/force_model.py b/lbmpy/phasefield_allen_cahn/force_model.py
deleted file mode 100644
index c3ff81f3aff504609ae9542ed72417125806c019..0000000000000000000000000000000000000000
--- a/lbmpy/phasefield_allen_cahn/force_model.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import sympy as sp
-
-from pystencils import Assignment
-from lbmpy.forcemodels import Simple, Luo
-
-
-class MultiphaseForceModel:
-    r"""
-    A force model based on PhysRevE.96.053301. This model realises the modified equilibrium distributions meaning the
-    force gets shifted by minus one half multiplied with the collision operator
-    """
-    def __init__(self, force, rho=1):
-        self._force = force
-        self._rho = rho
-        self.force_symp = sp.symbols(f"F_:{len(force)}")
-        self.subs_terms = [Assignment(rhs, lhs) for rhs, lhs in zip(self.force_symp, force)]
-
-    def __call__(self, lb_method):
-        simple = Simple(self.force_symp)
-        force = sp.Matrix(simple(lb_method))
-
-        moment_matrix = lb_method.moment_matrix
-
-        return sp.simplify(moment_matrix * force) / self._rho
-
-
-class CentralMomentMultiphaseForceModel:
-    r"""
-    A simple force model in the central moment space.
-    """
-    def __init__(self, force, rho=1):
-        self._force = force
-        self._rho = rho
-        self.force_symp = sp.symbols(f"F_:{len(force)}")
-        self.subs_terms = [Assignment(rhs, lhs) for rhs, lhs in zip(self.force_symp, force)]
-
-    def __call__(self, lb_method, **kwargs):
-        luo = Luo(self.force_symp)
-        force = sp.Matrix(luo(lb_method))
-
-        M = lb_method.moment_matrix
-        N = lb_method.shift_matrix
-
-        result = sp.simplify(M * force)
-        return sp.simplify(N * result) / self._rho
diff --git a/lbmpy/phasefield_allen_cahn/kernel_equations.py b/lbmpy/phasefield_allen_cahn/kernel_equations.py
index e5a63ef455bd4782f644c6cc19b8fcc98a1ce5d9..da56ede57b1e21ef1ea0c52fa5b657b921b964bf 100644
--- a/lbmpy/phasefield_allen_cahn/kernel_equations.py
+++ b/lbmpy/phasefield_allen_cahn/kernel_equations.py
@@ -1,14 +1,10 @@
 from pystencils.fd.derivation import FiniteDifferenceStencilDerivation
-from pystencils import Assignment
+from pystencils import Assignment, AssignmentCollection, Field
 
-from lbmpy.methods.momentbased.centralmomentbasedmethod import CentralMomentBasedLbMethod
-from lbmpy.moments import get_order
-from lbmpy.maxwellian_equilibrium import get_weights
-from lbmpy.fieldaccess import StreamPullTwoFieldsAccessor, StreamPushTwoFieldsAccessor, CollideOnlyInplaceAccessor
+from lbmpy import pdf_initialization_assignments
 from lbmpy.methods.abstractlbmethod import LbmCollisionRule
-
-from lbmpy.phasefield_allen_cahn.phasefield_simplifications import create_phasefield_simplification_strategy
-from lbmpy.phasefield_allen_cahn.force_model import CentralMomentMultiphaseForceModel
+from lbmpy.utils import second_order_moment_tensor
+from lbmpy.phasefield_allen_cahn.parameter_calculation import AllenCahnParameters
 
 import sympy as sp
 
@@ -46,7 +42,10 @@ def chemical_potential_symbolic(phi_field, stencil, beta, kappa):
             lap += res.apply(phi_field.center)
 
     # get the chemical potential
-    mu = 4.0 * beta * phi_field.center * (phi_field.center - 1.0) * (phi_field.center - 0.5) - kappa * lap
+    four = sp.Rational(4, 1)
+    one = sp.Rational(1, 1)
+    half = sp.Rational(1, 2)
+    mu = four * beta * phi_field.center * (phi_field.center - one) * (phi_field.center - half) - kappa * lap
     return mu
 
 
@@ -106,7 +105,7 @@ def normalized_isotropic_gradient_symbolic(phi_field, stencil, fd_stencil=None):
     if fd_stencil is None:
         fd_stencil = stencil
 
-    tmp = (sum(map(lambda x: x * x, isotropic_gradient_symbolic(phi_field, fd_stencil))) + 1.e-32) ** 0.5
+    tmp = (sum(map(lambda x: x * x, isotropic_gradient_symbolic(phi_field, fd_stencil))) + sp.Float(1e-32)) ** 0.5
 
     result = [x / tmp for x in isotropic_gradient_symbolic(phi_field, fd_stencil)]
     return result
@@ -131,56 +130,37 @@ def pressure_force(phi_field, stencil, density_heavy, density_light, fd_stencil=
     return result
 
 
-def viscous_force(lb_velocity_field, phi_field, mrt_method, tau, density_heavy, density_light, fd_stencil=None):
+def viscous_force(lb_velocity_field, phi_field, lb_method, tau, density_heavy, density_light, fd_stencil=None):
     r"""
     Get a symbolic expression for the viscous force
     Args:
         lb_velocity_field: hydrodynamic distribution function
         phi_field: phase-field
-        mrt_method: mrt lattice boltzmann method used for hydrodynamics
+        lb_method: lattice boltzmann method used for hydrodynamics
         tau: relaxation time of the hydrodynamic lattice boltzmann step
         density_heavy: density of the heavier fluid
         density_light: density of the lighter fluid
         fd_stencil: stencil to derive the finite differences of the isotropic gradient and the laplacian of the phase
         field. If it is not given the stencil of the LB method will be applied.
     """
-    stencil = mrt_method.stencil
-    dimensions = stencil.D
+    stencil = lb_method.stencil
 
     if fd_stencil is None:
         fd_stencil = stencil
 
-    iso_grad = isotropic_gradient_symbolic(phi_field, fd_stencil)
-
-    non_equilibrium = lb_velocity_field.center_vector - mrt_method.get_equilibrium_terms()
-
-    stress_tensor = [0] * 6
-    # Calculate Stress Tensor MRT
-    for i, d in enumerate(stencil):
-        stress_tensor[0] = sp.Add(stress_tensor[0], non_equilibrium[i] * (d[0] * d[0]))
-        stress_tensor[1] = sp.Add(stress_tensor[1], non_equilibrium[i] * (d[1] * d[1]))
-
-        if dimensions == 3:
-            stress_tensor[2] = sp.Add(stress_tensor[2], non_equilibrium[i] * (d[2] * d[2]))
-            stress_tensor[3] = sp.Add(stress_tensor[3], non_equilibrium[i] * (d[1] * d[2]))
-            stress_tensor[4] = sp.Add(stress_tensor[4], non_equilibrium[i] * (d[0] * d[2]))
+    iso_grad = sp.Matrix(isotropic_gradient_symbolic(phi_field, fd_stencil)[:stencil.D])
 
-        stress_tensor[5] = sp.Add(stress_tensor[5], non_equilibrium[i] * (d[0] * d[1]))
+    f_neq = lb_velocity_field.center_vector - lb_method.get_equilibrium_terms()
+    stress_tensor = second_order_moment_tensor(f_neq, lb_method.stencil)
+    normal_stress_tensor = stress_tensor * iso_grad
 
     density_difference = density_heavy - density_light
 
     # Calculate Viscous Force MRT
-    fmx = (0.5 - tau) * (stress_tensor[0] * iso_grad[0]
-                         + stress_tensor[5] * iso_grad[1]
-                         + stress_tensor[4] * iso_grad[2]) * density_difference
-
-    fmy = (0.5 - tau) * (stress_tensor[5] * iso_grad[0]
-                         + stress_tensor[1] * iso_grad[1]
-                         + stress_tensor[3] * iso_grad[2]) * density_difference
-
-    fmz = (0.5 - tau) * (stress_tensor[4] * iso_grad[0]
-                         + stress_tensor[3] * iso_grad[1]
-                         + stress_tensor[2] * iso_grad[2]) * density_difference
+    half = sp.Rational(1, 2)
+    fmx = (half - tau) * normal_stress_tensor[0] * density_difference
+    fmy = (half - tau) * normal_stress_tensor[1] * density_difference
+    fmz = (half - tau) * normal_stress_tensor[2] * density_difference if stencil.D == 3 else 0
 
     return [fmx, fmy, fmz]
 
@@ -204,19 +184,15 @@ def surface_tension_force(phi_field, stencil, beta, kappa, fd_stencil=None):
     return [chemical_potential * x for x in iso_grad]
 
 
-def hydrodynamic_force(lb_velocity_field, phi_field, lb_method, tau,
-                       density_heavy, density_light, kappa, beta, body_force, fd_stencil=None):
+def hydrodynamic_force(lb_velocity_field, phi_field, lb_method, parameters: AllenCahnParameters,
+                       body_force, fd_stencil=None):
     r"""
     Get a symbolic expression for the hydrodynamic force
     Args:
         lb_velocity_field: hydrodynamic distribution function
         phi_field: phase-field
         lb_method: Lattice boltzmann method used for hydrodynamics
-        tau: relaxation time of the hydrodynamic lattice boltzmann step
-        density_heavy: density of the heavier fluid
-        density_light: density of the lighter fluid
-        beta: coefficient related to surface tension and interface thickness
-        kappa: coefficient related to surface tension and interface thickness
+        parameters: AllenCahnParameters
         body_force: force acting on the fluids. Usually the gravity
         fd_stencil: stencil to derive the finite differences of the isotropic gradient and the laplacian of the phase
         field. If it is not given the stencil of the LB method will be applied.
@@ -226,6 +202,14 @@ def hydrodynamic_force(lb_velocity_field, phi_field, lb_method, tau,
     if fd_stencil is None:
         fd_stencil = stencil
 
+    density_heavy = parameters.symbolic_density_heavy
+    density_light = parameters.symbolic_density_light
+    tau_L = parameters.symbolic_tau_light
+    tau_H = parameters.symbolic_tau_heavy
+    tau = sp.Rational(1, 2) + tau_L + phi_field.center * (tau_H - tau_L)
+    beta = parameters.beta
+    kappa = parameters.kappa
+
     fp = pressure_force(phi_field, stencil, density_heavy, density_light, fd_stencil)
     fm = viscous_force(lb_velocity_field, phi_field, lb_method, tau, density_heavy, density_light, fd_stencil)
     fs = surface_tension_force(phi_field, stencil, beta, kappa, fd_stencil)
@@ -237,317 +221,201 @@ def hydrodynamic_force(lb_velocity_field, phi_field, lb_method, tau,
     return result
 
 
-def interface_tracking_force(phi_field, stencil, interface_thickness, fd_stencil=None):
+def interface_tracking_force(phi_field, stencil, parameters: AllenCahnParameters, fd_stencil=None,
+                             phi_heavy=1, phi_light=0):
     r"""
     Get a symbolic expression for the hydrodynamic force
     Args:
         phi_field: phase-field
         stencil: stencil of the phase-field distribution lattice Boltzmann step
-        interface_thickness: interface thickness
+        parameters: AllenCahnParameters
         fd_stencil: stencil to derive the finite differences of the isotropic gradient and the laplacian of the phase
         field. If it is not given the stencil of the LB method will be applied.
+        phi_heavy: phase field value in the bulk of the heavy fluid
+        phi_light: phase field value in the bulk of the light fluid
+
     """
     if fd_stencil is None:
         fd_stencil = stencil
 
+    phi_zero = sp.Rational(1, 2) * (phi_light + phi_heavy)
+
     normal_fd = normalized_isotropic_gradient_symbolic(phi_field, stencil, fd_stencil)
     result = []
+    interface_thickness = parameters.symbolic_interface_thickness
     for i in range(stencil.D):
-        result.append(((1.0 - 4.0 * (phi_field.center - 0.5) ** 2) / interface_thickness) * normal_fd[i])
+        fraction = (sp.Rational(1, 1) - sp.Rational(4, 1) * (phi_field.center - phi_zero) ** 2) / interface_thickness
+        result.append(sp.Rational(1, 3) * fraction * normal_fd[i])
 
     return result
 
 
-def get_update_rules_velocity(src_field, u_in, lb_method, force_model, density, sub_iterations=2):
-    r"""
-     Get assignments to update the velocity with a force shift
-     Args:
-         src_field: the source field of the hydrodynamic distribution function
-         u_in: velocity field
-         lb_method: mrt lattice boltzmann method used for hydrodynamics
-         force_model: one of the phase_field force models which are applied in the collision space
-         density: the interpolated density of the simulation
-         sub_iterations: number of updates of the velocity field
-     """
-    stencil = lb_method.stencil
+def hydrodynamic_force_assignments(lb_velocity_field, velocity_field, phi_field, lb_method,
+                                   parameters: AllenCahnParameters,
+                                   body_force, fd_stencil=None, sub_iterations=2):
 
-    rho = lb_method.conserved_quantity_computation.zeroth_order_moment_symbol
-    u_symp = lb_method.conserved_quantity_computation.first_order_moment_symbols
+    r"""
+    Get a symbolic expression for the hydrodynamic force
+    Args:
+        lb_velocity_field: hydrodynamic distribution function
+        velocity_field: velocity
+        phi_field: phase-field
+        lb_method: Lattice boltzmann method used for hydrodynamics
+        parameters: AllenCahnParameters
+        body_force: force acting on the fluids. Usually the gravity
+        fd_stencil: stencil to derive the finite differences of the isotropic gradient and the laplacian of the phase
+        field. If it is not given the stencil of the LB method will be applied.
+        sub_iterations: number of sub iterations for the hydrodynamic force
+    """
 
-    force = force_model._force
-    force_symp = force_model.force_symp
+    rho_L = parameters.symbolic_density_light
+    rho_H = parameters.symbolic_density_heavy
+    density = rho_L + phi_field.center * (rho_H - rho_L)
 
-    moment_matrix = lb_method.moment_matrix
+    stencil = lb_method.stencil
+    # method has to have a force model
+    symbolic_force = lb_method.force_model.symbolic_force_vector
 
-    moments = lb_method.moments
-    indices = list()
-    for i in range(len(moments)):
-        if get_order(moments[i]) == 1:
-            indices.append(i)
+    force = hydrodynamic_force(lb_velocity_field, phi_field, lb_method, parameters, body_force, fd_stencil=fd_stencil)
 
-    m0 = moment_matrix * sp.Matrix(src_field.center_vector)
+    cqc = lb_method.conserved_quantity_computation
 
-    update_u = list()
-    update_u.append(Assignment(rho, m0[0]))
+    u_symp = cqc.first_order_moment_symbols
+    cqe = cqc.equilibrium_input_equations_from_pdfs(lb_velocity_field.center_vector)
+    cqe = cqe.new_without_subexpressions()
 
+    cqe_velocity = [eq.rhs for eq in cqe.main_assignments[1:]]
     index = 0
     aleph = sp.symbols(f"aleph_:{stencil.D * sub_iterations}")
 
+    force_Assignments = []
+
     for i in range(stencil.D):
-        update_u.append(Assignment(aleph[i], u_in.center_vector[i]))
+        force_Assignments.append(Assignment(aleph[i], velocity_field.center_vector[i]))
         index += 1
 
     for k in range(sub_iterations - 1):
         subs_dict = dict(zip(u_symp, aleph[k * stencil.D:index]))
         for i in range(stencil.D):
-            update_u.append(Assignment(aleph[index], m0[indices[i]] + force[i].subs(subs_dict) / density / 2))
+            new_force = force[i].subs(subs_dict) / density
+            force_Assignments.append(Assignment(aleph[index], cqe_velocity[i].subs({symbolic_force[i]: new_force})))
             index += 1
 
     subs_dict = dict(zip(u_symp, aleph[index - stencil.D:index]))
 
     for i in range(stencil.D):
-        update_u.append(Assignment(force_symp[i], force[i].subs(subs_dict)))
-
-    for i in range(stencil.D):
-        update_u.append(Assignment(u_symp[i], m0[indices[i]] + force_symp[i] / density / 2))
+        force_Assignments.append(Assignment(symbolic_force[i], force[i].subs(subs_dict)))
 
-    return update_u
+    return force_Assignments
 
 
-def get_collision_assignments_hydro(lb_method, density, velocity_input, force_model, sub_iterations, symbolic_fields,
-                                    kernel_type):
+def add_interface_tracking_force(update_rule: LbmCollisionRule, force):
     r"""
-     Get collision assignments for the hydrodynamic lattice Boltzmann step. Here the force gets applied in the moment
-     space. Afterwards the transformation back to the pdf space happens.
+     Adds the interface tracking force to a lattice Boltzmann update rule
      Args:
-         lb_method: moment based lattice Boltzmann method
-         density: the interpolated density of the simulation
-         velocity_input: velocity field for the hydrodynamic and Allen-Chan LB step
-         force_model: one of the phase_field force models which are applied in the collision space
-         sub_iterations: number of updates of the velocity field
-         symbolic_fields: PDF fields for source and destination
-         kernel_type: collide_stream_push or collide_only
+         update_rule: lattice Boltzmann update rule
+         force: interface tracking force
      """
+    method = update_rule.method
+    symbolic_force = method.force_model.symbolic_force_vector
 
-    if isinstance(lb_method, CentralMomentBasedLbMethod) and not \
-            isinstance(force_model, CentralMomentMultiphaseForceModel):
-        raise ValueError("For central moment lb methods a central moment force model needs the be applied")
-
-    stencil = lb_method.stencil
-
-    rho = lb_method.conserved_quantity_computation.zeroth_order_moment_symbol
-
-    src_field = symbolic_fields['symbolic_field']
-    dst_field = symbolic_fields['symbolic_temporary_field']
-
-    if kernel_type == 'collide_stream_push':
-        accessor = StreamPushTwoFieldsAccessor()
-    else:
-        accessor = CollideOnlyInplaceAccessor()
-
-    u_symp = lb_method.conserved_quantity_computation.first_order_moment_symbols
+    for i in range(method.stencil.D):
+        update_rule.subexpressions += [Assignment(symbolic_force[i], force[i])]
 
-    moment_matrix = lb_method.moment_matrix
-    rel = sp.diag(*lb_method.relaxation_rates)
-    eq = sp.Matrix(lb_method.moment_equilibrium_values)
+    update_rule.topological_sort(sort_subexpressions=True, sort_main_assignments=False)
 
-    force_terms = force_model(lb_method)
-    eq = eq - sp.Rational(1, 2) * force_terms
+    return update_rule
 
-    pre = sp.symbols(f"pre_:{stencil.Q}")
-    post = sp.symbols(f"post_:{stencil.Q}")
 
-    to_moment_space = moment_matrix * sp.Matrix(accessor.read(src_field, stencil))
-    to_moment_space[0] = rho
-
-    main_assignments = list()
-    subexpressions = get_update_rules_velocity(src_field, velocity_input, lb_method, force_model,
-                                               density, sub_iterations=sub_iterations)
-
-    for i in range(0, stencil.Q):
-        subexpressions.append(Assignment(pre[i], to_moment_space[i]))
-
-    if isinstance(lb_method, CentralMomentBasedLbMethod):
-        n0 = lb_method.shift_matrix * sp.Matrix(pre)
-        to_central = sp.Matrix(sp.symbols(f"kappa_:{stencil.Q}"))
-        for i in range(0, stencil.Q):
-            subexpressions.append(Assignment(to_central[i], n0[i]))
-        pre = to_central
-
-    collision = sp.Matrix(pre) - rel * (sp.Matrix(pre) - eq) + force_terms
-
-    for i in range(0, stencil.Q):
-        subexpressions.append(Assignment(post[i], collision[i]))
-
-    if isinstance(lb_method, CentralMomentBasedLbMethod):
-        n0_back = lb_method.shift_matrix.inv() * sp.Matrix(post)
-        from_central = sp.Matrix(sp.symbols(f"kappa_post:{stencil.Q}"))
-        for i in range(0, stencil.Q):
-            subexpressions.append(Assignment(from_central[i], n0_back[i]))
-        post = from_central
-
-    to_pdf_space = moment_matrix.inv() * sp.Matrix(post)
-
-    for i in range(0, stencil.Q):
-        main_assignments.append(Assignment(accessor.write(dst_field, stencil)[i], to_pdf_space[i]))
-
-    for i in range(stencil.D):
-        main_assignments.append(Assignment(velocity_input.center_vector[i], u_symp[i]))
-
-    collision_rule = LbmCollisionRule(lb_method, main_assignments, subexpressions)
-
-    simplification = create_phasefield_simplification_strategy(lb_method)
-    collision_rule = simplification(collision_rule)
-
-    return collision_rule
-
-
-def get_collision_assignments_phase(lb_method, velocity_input, output, force_model, symbolic_fields, kernel_type):
+def add_hydrodynamic_force(update_rule: LbmCollisionRule, force, phi_field,
+                           hydro_pdfs, parameters: AllenCahnParameters):
     r"""
-     Get collision assignments for the phasefield lattice Boltzmann step. Here the force gets applied in the moment
-     space. Afterwards the transformation back to the pdf space happens.
+     Adds the interface tracking force to a lattice Boltzmann update rule
      Args:
-         lb_method: moment based lattice Boltzmann method
-         velocity_input: velocity field for the hydrodynamic and Allen-Chan LB step
-         output: output field for the phasefield (calles density as for normal LB update rules)
-         force_model: one of the phase_field force models which are applied in the collision space
-         symbolic_fields: PDF fields for source and destination
-         kernel_type: stream_pull_collide or collide_only
+         update_rule: lattice Boltzmann update rule
+         force: interface tracking force
+         phi_field: phase-field
+         hydro_pdfs: source field of the hydrodynamic PDFs
+         parameters: AllenCahnParameters
      """
+    rho_L = parameters.symbolic_density_light
+    rho_H = parameters.symbolic_density_heavy
+    density = rho_L + phi_field.center * (rho_H - rho_L)
 
-    stencil = lb_method.stencil
-
-    src_field = symbolic_fields['symbolic_field']
-    dst_field = symbolic_fields['symbolic_temporary_field']
-    output_phase_field = output['density']
-
-    if kernel_type == 'stream_pull_collide':
-        accessor = StreamPullTwoFieldsAccessor()
-    else:
-        accessor = CollideOnlyInplaceAccessor()
-
-    subexpressions = list()
-    main_assignments = list()
+    method = update_rule.method
+    symbolic_force = method.force_model.symbolic_force_vector
+    cqc = method.conserved_quantity_computation
+    rho = cqc.zeroth_order_moment_symbol
 
-    rho = lb_method.conserved_quantity_computation.zeroth_order_moment_symbol
-    u_symp = lb_method.conserved_quantity_computation.first_order_moment_symbols
+    force_subs = {f: f / density for f in symbolic_force}
 
-    moment_matrix = lb_method.moment_matrix
-    rel = sp.diag(*lb_method.relaxation_rates)
-    eq = sp.Matrix(lb_method.moment_equilibrium_values)
+    update_rule = update_rule.subs(force_subs)
 
-    force_terms = force_model(lb_method)
-    eq = eq - sp.Rational(1, 2) * force_terms
+    update_rule.subexpressions += [Assignment(rho, sum(hydro_pdfs.center_vector))]
+    update_rule.subexpressions += force
+    update_rule.topological_sort(sort_subexpressions=True, sort_main_assignments=False)
 
-    pre = sp.symbols(f"pre_:{stencil.Q}")
-    post = sp.symbols(f"post_:{stencil.Q}")
+    return update_rule
 
-    to_moment_space = moment_matrix * sp.Matrix(accessor.read(src_field, stencil))
-    to_moment_space[0] = rho
 
-    subexpressions.append(Assignment(rho, sum(accessor.read(src_field, stencil))))
-    for i in range(lb_method.dim):
-        subexpressions.append(Assignment(u_symp[i], velocity_input.center_vector[i]))
-    subexpressions.extend(force_model.subs_terms)
-
-    for i in range(stencil.Q):
-        subexpressions.append(Assignment(pre[i], to_moment_space[i]))
-
-    if isinstance(lb_method, CentralMomentBasedLbMethod):
-        n0 = lb_method.shift_matrix * sp.Matrix(pre)
-        to_central = sp.Matrix(sp.symbols(f"kappa_:{stencil.Q}"))
-        for i in range(stencil.Q):
-            subexpressions.append(Assignment(to_central[i], n0[i]))
-        pre = to_central
-
-    collision = sp.Matrix(pre) - rel * (sp.Matrix(pre) - eq) + force_terms
-
-    for i in range(stencil.Q):
-        subexpressions.append(Assignment(post[i], collision[i]))
-
-    if isinstance(lb_method, CentralMomentBasedLbMethod):
-        n0_back = lb_method.shift_matrix.inv() * sp.Matrix(post)
-        from_central = sp.Matrix(sp.symbols(f"kappa_post:{stencil.Q}"))
-        for i in range(stencil.Q):
-            subexpressions.append(Assignment(from_central[i], n0_back[i]))
-        post = from_central
-
-    to_pdf_space = moment_matrix.inv() * sp.Matrix(post)
-
-    for i in range(stencil.Q):
-        main_assignments.append(Assignment(accessor.write(dst_field, stencil)[i], to_pdf_space[i]))
-
-    main_assignments.append(Assignment(output_phase_field.center, sum(accessor.write(dst_field, stencil))))
-
-    collision_rule = LbmCollisionRule(lb_method, main_assignments, subexpressions)
-
-    simplification = create_phasefield_simplification_strategy(lb_method)
-    collision_rule = simplification(collision_rule)
-
-    return collision_rule
-
-
-def initializer_kernel_phase_field_lb(lb_phase_field, phi_field, velocity_field, mrt_method, interface_thickness,
+def initializer_kernel_phase_field_lb(lb_method, phi, velocity, ac_pdfs, parameters: AllenCahnParameters,
                                       fd_stencil=None):
     r"""
     Returns an assignment list for initializing the phase-field distribution functions
     Args:
-        lb_phase_field: source field of phase-field distribution function
-        phi_field: phase-field
-        velocity_field: velocity field
-        mrt_method: lattice Boltzmann method of the phase-field lattice Boltzmann step
-        interface_thickness: interface thickness
+        lb_method: lattice Boltzmann method of the phase-field lattice Boltzmann step
+        phi: order parameter of the Allen-Cahn LB step (phase field)
+        velocity: initial velocity
+        ac_pdfs: source field of the Allen-Cahn PDFs
+        parameters: AllenCahnParameters
         fd_stencil: stencil to derive the finite differences of the isotropic gradient and the laplacian of the phase
         field. If it is not given the stencil of the LB method will be applied.
     """
-    stencil = mrt_method.stencil
 
-    if fd_stencil is None:
-        fd_stencil = stencil
+    h_updates = pdf_initialization_assignments(lb_method, phi, velocity, ac_pdfs)
+    force_h = interface_tracking_force(phi, lb_method.stencil, parameters,
+                                       fd_stencil=fd_stencil)
 
-    weights = get_weights(stencil, c_s_sq=sp.Rational(1, 3))
-    u_symp = sp.symbols(f"u_:{stencil.D}")
+    cqc = lb_method.conserved_quantity_computation
 
-    normal_fd = normalized_isotropic_gradient_symbolic(phi_field, stencil, fd_stencil)
+    rho = cqc.zeroth_order_moment_symbol
+    u_symp = cqc.first_order_moment_symbols
+    symbolic_force = lb_method.force_model.symbolic_force_vector
+
+    macro_quantities = []
 
-    gamma = mrt_method.get_equilibrium_terms()
-    gamma = gamma.subs({sp.symbols("rho"): 1})
-    gamma_init = gamma.subs({x: y for x, y in zip(u_symp, velocity_field.center_vector)})
-    # create the kernels for the initialization of the h field
-    h_updates = list()
+    if isinstance(velocity, Field):
+        velocity = velocity.center_vector
 
-    def scalar_product(a, b):
-        return sum(a_i * b_i for a_i, b_i in zip(a, b))
+    if isinstance(phi, Field):
+        phi = phi.center
 
-    f = []
-    for i, d in enumerate(stencil):
-        f.append(weights[i] * ((1.0 - 4.0 * (phi_field.center - 0.5) ** 2) / interface_thickness)
-                 * scalar_product(d, normal_fd[0:stencil.D]))
+    for i in range(lb_method.stencil.D):
+        macro_quantities.append(Assignment(symbolic_force[i], force_h[i]))
 
-    for i, _ in enumerate(stencil):
-        h_updates.append(Assignment(lb_phase_field.center(i), phi_field.center * gamma_init[i] - 0.5 * f[i]))
+    for i in range(lb_method.stencil.D):
+        macro_quantities.append(Assignment(u_symp[i],
+                                           velocity[i] - sp.Rational(1, 2) * symbolic_force[i]))
+
+    h_updates = AssignmentCollection(main_assignments=h_updates.main_assignments, subexpressions=macro_quantities)
+    h_updates = h_updates.new_with_substitutions({rho: phi})
 
     return h_updates
 
 
-def initializer_kernel_hydro_lb(lb_velocity_field, velocity_field, mrt_method):
+def initializer_kernel_hydro_lb(lb_method, pressure, velocity, hydro_pdfs):
     r"""
     Returns an assignment list for initializing the velocity distribution functions
     Args:
-        lb_velocity_field: source field of velocity distribution function
-        velocity_field: velocity field
-        mrt_method: lattice Boltzmann method of the hydrodynamic lattice Boltzmann step
+        lb_method: lattice Boltzmann method of the hydrodynamic lattice Boltzmann step
+        pressure: order parameter of the hydrodynamic LB step (pressure)
+        velocity: initial velocity
+        hydro_pdfs: source field of the hydrodynamic PDFs
     """
-    stencil = mrt_method.stencil
-    weights = get_weights(stencil, c_s_sq=sp.Rational(1, 3))
-    u_symp = sp.symbols(f"u_:{stencil.D}")
-
-    gamma = mrt_method.get_equilibrium_terms()
-    gamma = gamma.subs({sp.symbols("rho"): 1})
-    gamma_init = gamma.subs({x: y for x, y in zip(u_symp, velocity_field.center_vector)})
+    symbolic_force = lb_method.force_model.symbolic_force_vector
+    force_subs = {f: 0 for f in symbolic_force}
 
-    g_updates = list()
-    for i, _ in enumerate(stencil):
-        g_updates.append(Assignment(lb_velocity_field.center(i), gamma_init[i] - weights[i]))
+    g_updates = pdf_initialization_assignments(lb_method, pressure, velocity, hydro_pdfs)
+    g_updates = g_updates.new_with_substitutions(force_subs)
 
     return g_updates
diff --git a/lbmpy/phasefield_allen_cahn/parameter_calculation.py b/lbmpy/phasefield_allen_cahn/parameter_calculation.py
index 2f3a84b2455498eca5d1733df3aea6a1458de01c..72cc5a2ecb6d33cc69408a7d87be4e0bf5dd6a70 100644
--- a/lbmpy/phasefield_allen_cahn/parameter_calculation.py
+++ b/lbmpy/phasefield_allen_cahn/parameter_calculation.py
@@ -1,4 +1,143 @@
 import math
+import sympy as sp
+
+
+class AllenCahnParameters:
+    def __init__(self, density_heavy: float, density_light: float,
+                 dynamic_viscosity_heavy: float, dynamic_viscosity_light: float,
+                 surface_tension: float, mobility: float = 0.2,
+                 gravitational_acceleration: float = 0.0, interface_thickness: int = 5):
+
+        self.density_heavy = density_heavy
+        self.density_light = density_light
+        self.dynamic_viscosity_heavy = dynamic_viscosity_heavy
+        self.dynamic_viscosity_light = dynamic_viscosity_light
+        self.surface_tension = surface_tension
+        self.mobility = mobility
+        self.gravitational_acceleration = gravitational_acceleration
+        self.interface_thickness = interface_thickness
+
+    @property
+    def kinematic_viscosity_heavy(self):
+        return self.dynamic_viscosity_heavy / self.density_heavy
+
+    @property
+    def kinematic_viscosity_light(self):
+        return self.dynamic_viscosity_light / self.density_light
+
+    @property
+    def relaxation_time_heavy(self):
+        return 3.0 * self.kinematic_viscosity_heavy
+
+    @property
+    def relaxation_time_light(self):
+        return 3.0 * self.kinematic_viscosity_light
+
+    @property
+    def omega_phi(self):
+        return 1.0 / (0.5 + (3.0 * self.mobility))
+
+    @property
+    def symbolic_density_heavy(self):
+        return sp.Symbol("rho_H")
+
+    @property
+    def symbolic_density_light(self):
+        return sp.Symbol("rho_L")
+
+    @property
+    def symbolic_tau_heavy(self):
+        return sp.Symbol("tau_H")
+
+    @property
+    def symbolic_tau_light(self):
+        return sp.Symbol("tau_L")
+
+    @property
+    def symbolic_omega_phi(self):
+        return sp.Symbol("omega_phi")
+
+    @property
+    def symbolic_surface_tension(self):
+        return sp.Symbol("sigma")
+
+    @property
+    def symbolic_mobility(self):
+        return sp.Symbol("M_m")
+
+    @property
+    def symbolic_gravitational_acceleration(self):
+        return sp.Symbol("F_g")
+
+    @property
+    def symbolic_interface_thickness(self):
+        return sp.Symbol("W")
+
+    @property
+    def beta(self):
+        return sp.Rational(12, 1) * (self.symbolic_surface_tension / self.symbolic_interface_thickness)
+
+    @property
+    def kappa(self):
+        return sp.Rational(3, 2) * self.symbolic_surface_tension * self.symbolic_interface_thickness
+
+    def omega(self, phase_field):
+        tau_L = self.symbolic_tau_light
+        tau_H = self.symbolic_tau_heavy
+        tau = sp.Rational(1, 2) + tau_L + phase_field.center * (tau_H - tau_L)
+        return sp.simplify(1 / tau)
+
+    def parameter_map(self):
+        result = {self.symbolic_density_heavy: self.density_heavy,
+                  self.symbolic_density_light: self.density_light,
+                  self.symbolic_tau_heavy: self.relaxation_time_heavy,
+                  self.symbolic_tau_light: self.relaxation_time_light,
+                  self.symbolic_omega_phi: self.omega_phi,
+                  self.symbolic_gravitational_acceleration: self.gravitational_acceleration,
+                  self.symbolic_interface_thickness: self.interface_thickness,
+                  self.symbolic_mobility: self.mobility,
+                  self.symbolic_surface_tension: self.surface_tension}
+        return result
+
+    @property
+    def symbolic_to_numeric_map(self):
+        return {t.name: self.parameter_map()[t] for t in self.parameter_map()}
+
+    def _repr_html_(self):
+        names = ("Density heavy phase",
+                 "Density light phase",
+                 "Relaxation time heavy phase",
+                 "Relaxation time light phase",
+                 "Relaxation rate Allen Cahn LB",
+                 "Gravitational acceleration",
+                 "Interface thickness",
+                 "Mobility",
+                 "Surface tension")
+
+        table = """
+        <table style="border:none; width: 100%">
+            <tr {nb}>
+                <th {nb} >Name</th>
+                <th {nb} >SymPy Symbol </th>
+                <th {nb} >Value</th>
+            </tr>
+            {content}
+        </table>
+        """
+        content = ""
+        for name, (symbol, value) in zip(names, self.parameter_map().items()):
+            vals = {
+                'Name': name,
+                'Sympy Symbol': sp.latex(symbol),
+                'numeric value': sp.latex(value),
+                'nb': 'style="border:none"',
+            }
+            content += """<tr {nb}>
+                            <td {nb}>{Name}</td>
+                            <td {nb}>${Sympy Symbol}$</td>
+                            <td {nb}>${numeric value}$</td>
+                         </tr>\n""".format(**vals)
+        return table.format(content=content, nb='style="border:none"')
 
 
 def calculate_parameters_rti(reference_length=256,
@@ -39,25 +178,16 @@ def calculate_parameters_rti(reference_length=256,
 
     density_light = density_heavy / density_ratio
 
-    kinematic_viscosity_heavy = dynamic_viscosity_heavy / density_heavy
-    kinematic_viscosity_light = dynamic_viscosity_light / density_light
-
-    relaxation_time_heavy = 3.0 * kinematic_viscosity_heavy
-    relaxation_time_light = 3.0 * kinematic_viscosity_light
-
     surface_tension = (dynamic_viscosity_heavy * reference_velocity) / capillary_number
     mobility = (reference_velocity * reference_length) / peclet_number
 
-    parameters = {
-        "density_light": density_light,
-        "dynamic_viscosity_heavy": dynamic_viscosity_heavy,
-        "dynamic_viscosity_light": dynamic_viscosity_light,
-        "relaxation_time_heavy": relaxation_time_heavy,
-        "relaxation_time_light": relaxation_time_light,
-        "gravitational_acceleration": -g,
-        "mobility": mobility,
-        "surface_tension": surface_tension
-    }
+    parameters = AllenCahnParameters(density_heavy=density_heavy,
+                                     density_light=density_light,
+                                     dynamic_viscosity_heavy=dynamic_viscosity_heavy,
+                                     dynamic_viscosity_light=dynamic_viscosity_light,
+                                     surface_tension=surface_tension,
+                                     mobility=mobility,
+                                     gravitational_acceleration=-g)
     return parameters
 
 
@@ -93,23 +223,14 @@ def calculate_dimensionless_rising_bubble(reference_time=18000,
     dynamic_viscosity_heavy = (density_heavy * math.sqrt(g * bubble_diameter ** 3)) / reynolds_number
     dynamic_viscosity_light = dynamic_viscosity_heavy / viscosity_ratio
 
-    kinematic_viscosity_heavy = dynamic_viscosity_heavy / density_heavy
-    kinematic_viscosity_light = dynamic_viscosity_light / density_light
-
-    relaxation_time_heavy = 3 * kinematic_viscosity_heavy
-    relaxation_time_light = 3 * kinematic_viscosity_light
-
     surface_tension = (density_heavy - density_light) * g * bubble_diameter ** 2 / bond_number
     # calculation of the Morton number
     # Mo = gravitational_acceleration * dynamic_viscosity_heavy / (density_heavy * surface_tension ** 3)
 
-    parameters = {
-        "density_light": density_light,
-        "dynamic_viscosity_heavy": dynamic_viscosity_heavy,
-        "dynamic_viscosity_light": dynamic_viscosity_light,
-        "relaxation_time_heavy": relaxation_time_heavy,
-        "relaxation_time_light": relaxation_time_light,
-        "gravitational_acceleration": -g,
-        "surface_tension": surface_tension
-    }
+    parameters = AllenCahnParameters(density_heavy=density_heavy,
+                                     density_light=density_light,
+                                     dynamic_viscosity_heavy=dynamic_viscosity_heavy,
+                                     dynamic_viscosity_light=dynamic_viscosity_light,
+                                     surface_tension=surface_tension,
+                                     gravitational_acceleration=-g)
     return parameters
diff --git a/lbmpy/turbulence_models.py b/lbmpy/turbulence_models.py
index 6a667a81c82ba766b7097b71622fa9fe2e45480b..bf43aa48d2edaa41c781747bf579d392625f43da 100644
--- a/lbmpy/turbulence_models.py
+++ b/lbmpy/turbulence_models.py
@@ -1,21 +1,10 @@
 import sympy as sp
 
 from lbmpy.relaxationrates import get_shear_relaxation_rate
+from lbmpy.utils import frobenius_norm, second_order_moment_tensor
 from pystencils import Assignment
 
 
-def second_order_moment_tensor(function_values, stencil):
-    """Returns (D x D) Matrix of second order moments of the given function where D is the dimension"""
-    assert len(function_values) == stencil.Q
-    return sp.Matrix(stencil.D, stencil.D, lambda i, j: sum(c[i] * c[j] * f for f, c in zip(function_values, stencil)))
-
-
-def frobenius_norm(matrix, factor=1):
-    """Computes the Frobenius norm of a matrix defined as the square root of the sum of squared matrix elements
-    The optional factor is added inside the square root"""
-    return sp.sqrt(sum(i * i for i in matrix) * factor)
-
-
 def add_smagorinsky_model(collision_rule, smagorinsky_constant, omega_output_field=None):
     r""" Adds a smagorinsky model to a lattice Boltzmann collision rule. To add the Smagorinsky model to a LB scheme
         one has to first compute the strain rate tensor $S_{ij}$ in each cell, and compute the turbulent
diff --git a/lbmpy/utils.py b/lbmpy/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..7416bcd1dc3d06afe75e63a555e2cd9f09d36c3c
--- /dev/null
+++ b/lbmpy/utils.py
@@ -0,0 +1,13 @@
+import sympy as sp
+
+
+def second_order_moment_tensor(function_values, stencil):
+    """Returns (D x D) Matrix of second order moments of the given function where D is the dimension"""
+    assert len(function_values) == stencil.Q
+    return sp.Matrix(stencil.D, stencil.D, lambda i, j: sum(c[i] * c[j] * f for f, c in zip(function_values, stencil)))
+
+
+def frobenius_norm(matrix, factor=1):
+    """Computes the Frobenius norm of a matrix defined as the square root of the sum of squared matrix elements
+    The optional factor is added inside the square root"""
+    return sp.sqrt(sum(i * i for i in matrix) * factor)
diff --git a/lbmpy_tests/phasefield_allen_cahn/test_analytical.py b/lbmpy_tests/phasefield_allen_cahn/test_analytical.py
index 51c3da131ea0c31771a741420c339b2a8603e346..93065066138f8745737356fcb4fedc9c021f6947 100644
--- a/lbmpy_tests/phasefield_allen_cahn/test_analytical.py
+++ b/lbmpy_tests/phasefield_allen_cahn/test_analytical.py
@@ -15,8 +15,8 @@ def test_analytical():
                                                        density_ratio=1000,
                                                        viscosity_ratio=100)
 
-    np.isclose(parameters["density_light"], 0.001, rtol=1e-05, atol=1e-08, equal_nan=False)
-    np.isclose(parameters["gravitational_acceleration"], -9.876543209876543e-08, rtol=1e-05, atol=1e-08, equal_nan=False)
+    np.isclose(parameters.density_light, 0.001, rtol=1e-05, atol=1e-08, equal_nan=False)
+    np.isclose(parameters.gravitational_acceleration, -9.876543209876543e-08, rtol=1e-05, atol=1e-08, equal_nan=False)
 
     parameters = calculate_parameters_rti(reference_length=128,
                                           reference_time=18000,
@@ -28,10 +28,10 @@ def test_analytical():
                                           density_ratio=3,
                                           viscosity_ratio=3)
 
-    np.isclose(parameters["density_light"], 1/3, rtol=1e-05, atol=1e-08, equal_nan=False)
-    np.isclose(parameters["gravitational_acceleration"], -3.9506172839506174e-07,
+    np.isclose(parameters.density_light, 1/3, rtol=1e-05, atol=1e-08, equal_nan=False)
+    np.isclose(parameters.gravitational_acceleration, -3.9506172839506174e-07,
                rtol=1e-05, atol=1e-08, equal_nan=False)
-    np.isclose(parameters["mobility"], 0.0012234169653524492, rtol=1e-05, atol=1e-08, equal_nan=False)
+    np.isclose(parameters.mobility, 0.0012234169653524492, rtol=1e-05, atol=1e-08, equal_nan=False)
 
     rs = analytic_rising_speed(1-6, 20, 0.01)
     np.isclose(rs, 16666.666666666668, rtol=1e-05, atol=1e-08, equal_nan=False)
diff --git a/lbmpy_tests/phasefield_allen_cahn/test_codegen_3d.py b/lbmpy_tests/phasefield_allen_cahn/test_codegen_3d.py
deleted file mode 100644
index f799f3489196726e51418b2908851ea8fbc2c0bd..0000000000000000000000000000000000000000
--- a/lbmpy_tests/phasefield_allen_cahn/test_codegen_3d.py
+++ /dev/null
@@ -1,111 +0,0 @@
-from lbmpy.creationfunctions import create_lb_method, LBMConfig, LBMOptimisation
-from lbmpy.enums import Method, Stencil
-from lbmpy.phasefield_allen_cahn.force_model import MultiphaseForceModel
-from lbmpy.phasefield_allen_cahn.kernel_equations import (get_collision_assignments_phase,
-                                                          get_collision_assignments_hydro, hydrodynamic_force,
-                                                          initializer_kernel_hydro_lb,
-                                                          initializer_kernel_phase_field_lb,
-                                                          interface_tracking_force)
-from lbmpy.stencils import LBStencil
-from pystencils import fields
-
-
-def test_allen_cahn_lb():
-    stencil_phase = LBStencil(Stencil.D3Q15)
-    # fields
-    u = fields("vel_field(" + str(stencil_phase.D) + "): [" + str(stencil_phase.D) + "D]", layout='fzyx')
-    C = fields("phase_field: [" + str(stencil_phase.D) + "D]", layout='fzyx')
-    C_tmp = fields("phase_field_tmp: [" + str(stencil_phase.D) + "D]", layout='fzyx')
-
-    h = fields("lb_phase_field(" + str(len(stencil_phase)) + "): [" + str(stencil_phase.D) + "D]", layout='fzyx')
-    h_tmp = fields("lb_phase_field_tmp(" + str(len(stencil_phase)) + "): [" + str(stencil_phase.D) + "D]", layout='fzyx')
-
-    M = 0.02
-    W = 5
-    w_c = 1.0 / (0.5 + (3.0 * M))
-
-    lbm_config = LBMConfig(stencil=stencil_phase, method=Method.SRT,
-                           relaxation_rate=w_c, compressible=True)
-
-    method_phase = create_lb_method(lbm_config=lbm_config)
-
-    h_updates = initializer_kernel_phase_field_lb(h, C, u, method_phase, W)
-
-    force_h = [f / 3 for f in interface_tracking_force(C, stencil_phase, W)]
-    force_model_h = MultiphaseForceModel(force=force_h)
-
-    allen_cahn_lb = get_collision_assignments_phase(lb_method=method_phase,
-                                                    velocity_input=u,
-                                                    output={'density': C_tmp},
-                                                    force_model=force_model_h,
-                                                    symbolic_fields={"symbolic_field": h,
-                                                                     "symbolic_temporary_field": h_tmp},
-                                                    kernel_type='stream_pull_collide')
-
-    allen_cahn_lb = get_collision_assignments_phase(lb_method=method_phase,
-                                                    velocity_input=u,
-                                                    output={'density': C_tmp},
-                                                    force_model=force_model_h,
-                                                    symbolic_fields={"symbolic_field": h,
-                                                                     "symbolic_temporary_field": h_tmp},
-                                                    kernel_type='collide_only')
-
-
-def test_hydro_lb():
-    stencil_hydro = LBStencil(Stencil.D3Q27)
-
-    density_liquid = 1.0
-    density_gas = 0.001
-    surface_tension = 0.0001
-    W = 5
-
-    # phase-field parameter
-    drho3 = (density_liquid - density_gas) / 3
-    # coefficient related to surface tension
-    beta = 12.0 * (surface_tension / W)
-    # coefficient related to surface tension
-    kappa = 1.5 * surface_tension * W
-
-    u = fields("vel_field(" + str(stencil_hydro.D) + "): [" + str(stencil_hydro.D) + "D]", layout='fzyx')
-    C = fields("phase_field: [" + str(stencil_hydro.D) + "D]", layout='fzyx')
-
-    g = fields("lb_velocity_field(" + str(stencil_hydro.Q) + "): [" + str(stencil_hydro.D) + "D]", layout='fzyx')
-    g_tmp = fields("lb_velocity_field_tmp(" + str(stencil_hydro.Q) + "): [" + str(stencil_hydro.D) + "D]", layout='fzyx')
-
-    # calculate the relaxation rate for the hydro lb as well as the body force
-    density = density_gas + C.center * (density_liquid - density_gas)
-    # force acting on all phases of the model
-    body_force = [0, 0, 0]
-
-    relaxation_time = 0.03 + 0.5
-    relaxation_rate = 1.0 / relaxation_time
-
-    lbm_config = LBMConfig(stencil=stencil_hydro, method=Method.MRT,
-                           weighted=True, relaxation_rates=[relaxation_rate, 1, 1, 1, 1, 1])
-
-    method_hydro = create_lb_method(lbm_config=lbm_config)
-
-    # create the kernels for the initialization of the g and h field
-    g_updates = initializer_kernel_hydro_lb(g, u, method_hydro)
-
-    force_g = hydrodynamic_force(g, C, method_hydro,
-                                 relaxation_time, density_liquid, density_gas, kappa, beta, body_force)
-    force_model_g = MultiphaseForceModel(force=force_g, rho=density)
-
-    hydro_lb_update_rule_normal = get_collision_assignments_hydro(lb_method=method_hydro,
-                                                                  density=density,
-                                                                  velocity_input=u,
-                                                                  force_model=force_model_g,
-                                                                  sub_iterations=2,
-                                                                  symbolic_fields={"symbolic_field": g,
-                                                                                   "symbolic_temporary_field": g_tmp},
-                                                                  kernel_type='collide_only')
-
-    hydro_lb_update_rule_push = get_collision_assignments_hydro(lb_method=method_hydro,
-                                                                density=density,
-                                                                velocity_input=u,
-                                                                force_model=force_model_g,
-                                                                sub_iterations=2,
-                                                                symbolic_fields={"symbolic_field": g,
-                                                                                 "symbolic_temporary_field": g_tmp},
-                                                                kernel_type='collide_stream_push')
diff --git a/lbmpy_tests/phasefield_allen_cahn/test_phase_field_allen_cahn_2d.ipynb b/lbmpy_tests/phasefield_allen_cahn/test_phase_field_allen_cahn_2d.ipynb
deleted file mode 100644
index c942b4189699a04e8c40e3928f188cf6ed055383..0000000000000000000000000000000000000000
--- a/lbmpy_tests/phasefield_allen_cahn/test_phase_field_allen_cahn_2d.ipynb
+++ /dev/null
@@ -1,434 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from collections import OrderedDict\n",
-    "import math\n",
-    "\n",
-    "from pystencils.session import *\n",
-    "from lbmpy.session import *\n",
-    "\n",
-    "from pystencils.boundaries.boundaryhandling import BoundaryHandling\n",
-    "\n",
-    "from lbmpy.moments import MOMENT_SYMBOLS\n",
-    "\n",
-    "from lbmpy.methods.creationfunctions import create_with_discrete_maxwellian_eq_moments\n",
-    "\n",
-    "from lbmpy.phasefield_allen_cahn.parameter_calculation import calculate_parameters_rti\n",
-    "from lbmpy.phasefield_allen_cahn.kernel_equations import *\n",
-    "from lbmpy.phasefield_allen_cahn.force_model import CentralMomentMultiphaseForceModel\n",
-    "from lbmpy.phasefield_allen_cahn.contact_angle import ContactAngle"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "No pycuda installed\n"
-     ]
-    }
-   ],
-   "source": [
-    "try:\n",
-    "    import pycuda\n",
-    "except ImportError:\n",
-    "    pycuda = None\n",
-    "    target = ps.Target.CPU\n",
-    "    print('No pycuda installed')\n",
-    "\n",
-    "if pycuda:\n",
-    "    target = ps.Target.GPU"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "stencil_phase = LBStencil(Stencil.D2Q9)\n",
-    "stencil_hydro = LBStencil(Stencil.D2Q9)\n",
-    "fd_stencil = LBStencil(Stencil.D2Q9)\n",
-    "assert stencil_phase.D == stencil_hydro.D\n",
-    "\n",
-    "dimensions = stencil_phase.D"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# domain \n",
-    "L0 = 256\n",
-    "domain_size = (L0, 4 * L0)\n",
-    "# time step\n",
-    "timesteps = 1000\n",
-    "\n",
-    "# reference time\n",
-    "reference_time = 8000\n",
-    "# density of the heavier fluid\n",
-    "rho_H = 1.0\n",
-    "\n",
-    "# calculate the parameters for the RTI\n",
-    "parameters = calculate_parameters_rti(reference_length=L0,\n",
-    "                                      reference_time=reference_time,\n",
-    "                                      density_heavy=rho_H,\n",
-    "                                      capillary_number=0.44,\n",
-    "                                      reynolds_number=3000,\n",
-    "                                      atwood_number=0.998,\n",
-    "                                      peclet_number=1000,\n",
-    "                                      density_ratio=1000,\n",
-    "                                      viscosity_ratio=100)\n",
-    "# get the parameters\n",
-    "rho_L = parameters.get(\"density_light\")\n",
-    "\n",
-    "mu_H = parameters.get(\"dynamic_viscosity_heavy\")\n",
-    "mu_L = parameters.get(\"dynamic_viscosity_light\")\n",
-    "\n",
-    "tau_H = parameters.get(\"relaxation_time_heavy\")\n",
-    "tau_L = parameters.get(\"relaxation_time_light\")\n",
-    "\n",
-    "sigma = parameters.get(\"surface_tension\")\n",
-    "M = parameters.get(\"mobility\")\n",
-    "gravitational_acceleration = parameters.get(\"gravitational_acceleration\")\n",
-    "\n",
-    "\n",
-    "drho3 = (rho_H - rho_L)/3\n",
-    "# interface thickness\n",
-    "W = 5\n",
-    "# coeffcient related to surface tension\n",
-    "beta = 12.0 * (sigma/W)\n",
-    "# coeffcient related to surface tension\n",
-    "kappa = 1.5 * sigma*W\n",
-    "# relaxation rate allen cahn (h)\n",
-    "w_c = 1.0/(0.5 + (3.0 * M))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dh = ps.create_data_handling((domain_size), periodicity=(True, False), parallel=False, default_target=target)\n",
-    "\n",
-    "g = dh.add_array(\"g\", values_per_cell=len(stencil_hydro))\n",
-    "dh.fill(\"g\", 0.0, ghost_layers=True)\n",
-    "h = dh.add_array(\"h\",values_per_cell=len(stencil_phase))\n",
-    "dh.fill(\"h\", 0.0, ghost_layers=True)\n",
-    "\n",
-    "g_tmp = dh.add_array(\"g_tmp\", values_per_cell=len(stencil_hydro))\n",
-    "dh.fill(\"g_tmp\", 0.0, ghost_layers=True)\n",
-    "h_tmp = dh.add_array(\"h_tmp\",values_per_cell=len(stencil_phase))\n",
-    "dh.fill(\"h_tmp\", 0.0, ghost_layers=True)\n",
-    "\n",
-    "u = dh.add_array(\"u\", values_per_cell=dh.dim)\n",
-    "dh.fill(\"u\", 0.0, ghost_layers=True)\n",
-    "\n",
-    "C = dh.add_array(\"C\")\n",
-    "dh.fill(\"C\", 0.0, ghost_layers=True)\n",
-    "C_tmp = dh.add_array(\"C_tmp\")\n",
-    "dh.fill(\"C_tmp\", 0.0, ghost_layers=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tau = 0.5 + tau_L + (C.center) * (tau_H - tau_L)\n",
-    "s8 = 1/(tau)\n",
-    "\n",
-    "rho = rho_L + (C.center) * (rho_H - rho_L)\n",
-    "\n",
-    "body_force = [0, 0, 0]\n",
-    "body_force[1] = gravitational_acceleration * rho"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config = ps.CreateKernelConfig(target=dh.default_target, cpu_openmp=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config_phase = LBMConfig(stencil=stencil_phase, method=Method.CENTRAL_MOMENT, compressible=True,\n",
-    "                         relaxation_rate=1, equilibrium_order=4)\n",
-    "\n",
-    "config_hydro = LBMConfig(stencil=stencil_hydro, method=Method.CENTRAL_MOMENT, compressible=False,\n",
-    "                         relaxation_rate=s8, equilibrium_order=4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "method_phase = create_lb_method(lbm_config=config_phase)\n",
-    "method_phase.set_first_moment_relaxation_rate(w_c)\n",
-    "\n",
-    "method_hydro = create_lb_method(lbm_config=config_hydro)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# initialize the domain\n",
-    "def Initialize_distributions():\n",
-    "    Nx = domain_size[0]\n",
-    "    Ny = domain_size[1]\n",
-    "    \n",
-    "    for block in dh.iterate(ghost_layers=True, inner_ghost_layers=False):\n",
-    "        x = np.zeros_like(block.midpoint_arrays[0])\n",
-    "        x[:, :] = block.midpoint_arrays[0]\n",
-    "        \n",
-    "        y = np.zeros_like(block.midpoint_arrays[1])\n",
-    "        y[:, :] = block.midpoint_arrays[1]\n",
-    "\n",
-    "        y -= 2 * L0\n",
-    "        tmp = 0.1 * Nx * np.cos((2 * math.pi * x) / Nx)\n",
-    "        init_values = 0.5 + 0.5 * np.tanh((y - tmp) / (W / 2))\n",
-    "        block[\"C\"][:, :] = init_values\n",
-    "        \n",
-    "    if target == ps.Target.GPU:\n",
-    "        dh.all_to_gpu()            \n",
-    "    \n",
-    "    dh.run_kernel(h_init)\n",
-    "    dh.run_kernel(g_init)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "h_updates = initializer_kernel_phase_field_lb(h, C, u, method_phase, W, fd_stencil=fd_stencil)\n",
-    "g_updates = initializer_kernel_hydro_lb(g, u, method_hydro)\n",
-    "\n",
-    "h_init = ps.create_kernel(h_updates, config=config).compile()\n",
-    "g_init = ps.create_kernel(g_updates, config=config).compile()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "force_h = [f / 3 for f in interface_tracking_force(C, stencil_phase, W, fd_stencil=stencil_phase)]\n",
-    "force_model_h = CentralMomentMultiphaseForceModel(force=force_h)\n",
-    "\n",
-    "force_g = hydrodynamic_force(g, C, method_hydro, tau, rho_H, rho_L, kappa, beta, body_force)\n",
-    "force_model_g = CentralMomentMultiphaseForceModel(force=force_g, rho=rho)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [],
-   "source": [
-    "allen_cahn_lb = get_collision_assignments_phase(lb_method=method_phase,\n",
-    "                                                velocity_input=u,\n",
-    "                                                output={'density': C_tmp},\n",
-    "                                                force_model=force_model_h,\n",
-    "                                                symbolic_fields={\"symbolic_field\": h,\n",
-    "                                                                 \"symbolic_temporary_field\": h_tmp},\n",
-    "                                                kernel_type='stream_pull_collide')\n",
-    "\n",
-    "allen_cahn_lb = sympy_cse(allen_cahn_lb)\n",
-    "\n",
-    "ast_allen_cahn_lb = ps.create_kernel(allen_cahn_lb, config=config)\n",
-    "kernel_allen_cahn_lb = ast_allen_cahn_lb.compile()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "hydro_lb_update_rule = get_collision_assignments_hydro(lb_method=method_hydro,\n",
-    "                                                       density=rho,\n",
-    "                                                       velocity_input=u,\n",
-    "                                                       force_model=force_model_g,\n",
-    "                                                       sub_iterations=2,\n",
-    "                                                       symbolic_fields={\"symbolic_field\": g,\n",
-    "                                                                        \"symbolic_temporary_field\": g_tmp},\n",
-    "                                                       kernel_type='collide_stream_push')\n",
-    "\n",
-    "hydro_lb_update_rule = sympy_cse(hydro_lb_update_rule)\n",
-    "\n",
-    "ast_hydro_lb = ps.create_kernel(hydro_lb_update_rule, config=config)\n",
-    "kernel_hydro_lb = ast_hydro_lb.compile()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# periodic Boundarys for g, h and C\n",
-    "periodic_BC_C = dh.synchronization_function(C.name, target=dh.default_target, optimization = {\"openmp\": True})\n",
-    "\n",
-    "periodic_BC_g = LBMPeriodicityHandling(stencil=stencil_hydro, data_handling=dh, pdf_field_name=g.name,\n",
-    "                                       streaming_pattern='push')\n",
-    "periodic_BC_h = LBMPeriodicityHandling(stencil=stencil_phase, data_handling=dh, pdf_field_name=h.name,\n",
-    "                                       streaming_pattern='pull')\n",
-    "\n",
-    "# No slip boundary for the phasefield lbm\n",
-    "bh_allen_cahn = LatticeBoltzmannBoundaryHandling(method_phase, dh, 'h',\n",
-    "                                                 target=dh.default_target, name='boundary_handling_h',\n",
-    "                                                 streaming_pattern='pull')\n",
-    "\n",
-    "# No slip boundary for the velocityfield lbm\n",
-    "bh_hydro = LatticeBoltzmannBoundaryHandling(method_hydro, dh, 'g' ,\n",
-    "                                            target=dh.default_target, name='boundary_handling_g',\n",
-    "                                            streaming_pattern='push')\n",
-    "\n",
-    "contact_angle = BoundaryHandling(dh, C.name, fd_stencil, target=dh.default_target)\n",
-    "\n",
-    "contact = ContactAngle(45, W)\n",
-    "wall = NoSlip()\n",
-    "\n",
-    "if dimensions == 2:\n",
-    "    bh_allen_cahn.set_boundary(wall, make_slice[:, 0])\n",
-    "    bh_allen_cahn.set_boundary(wall, make_slice[:, -1])\n",
-    "\n",
-    "    bh_hydro.set_boundary(wall, make_slice[:, 0])\n",
-    "    bh_hydro.set_boundary(wall, make_slice[:, -1])\n",
-    "    \n",
-    "    contact_angle.set_boundary(contact, make_slice[:, 0])\n",
-    "    contact_angle.set_boundary(contact, make_slice[:, -1])\n",
-    "else:\n",
-    "    bh_allen_cahn.set_boundary(wall, make_slice[:, 0, :])\n",
-    "    bh_allen_cahn.set_boundary(wall, make_slice[:, -1, :])\n",
-    "\n",
-    "    bh_hydro.set_boundary(wall, make_slice[:, 0, :])\n",
-    "    bh_hydro.set_boundary(wall, make_slice[:, -1, :])\n",
-    "    \n",
-    "    contact_angle.set_boundary(contact, make_slice[:, 0, :])\n",
-    "    contact_angle.set_boundary(contact, make_slice[:, -1, :])\n",
-    "\n",
-    "\n",
-    "bh_allen_cahn.prepare()\n",
-    "bh_hydro.prepare()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# definition of the timestep for the immiscible fluids model\n",
-    "def Improved_PhaseField_h_g():\n",
-    "    periodic_BC_h()\n",
-    "    bh_allen_cahn()\n",
-    "    \n",
-    "    # run the phase-field LB\n",
-    "    dh.run_kernel(kernel_allen_cahn_lb)\n",
-    "    dh.swap(\"C\", \"C_tmp\")\n",
-    "    contact_angle()\n",
-    "    # periodic BC of the phase-field\n",
-    "    periodic_BC_C()\n",
-    "    \n",
-    "    dh.run_kernel(kernel_hydro_lb)\n",
-    "    periodic_BC_g()\n",
-    "    bh_hydro()\n",
-    "\n",
-    "    # field swaps\n",
-    "    dh.swap(\"h\", \"h_tmp\")\n",
-    "    dh.swap(\"g\", \"g_tmp\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [],
-   "source": [
-    "Initialize_distributions()\n",
-    "\n",
-    "for i in range(0, timesteps): \n",
-    "    Improved_PhaseField_h_g()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if target == ps.Target.GPU:\n",
-    "    dh.to_cpu(\"C\")\n",
-    "\n",
-    "Ny = domain_size[1]\n",
-    "\n",
-    "pos_liquid_front = (np.argmax(dh.cpu_arrays[\"C\"][L0//2, :] > 0.5) - Ny//2)/L0\n",
-    "pos_bubble_front = (np.argmax(dh.cpu_arrays[\"C\"][0, :] > 0.5) - Ny//2)/L0"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "assert(np.isclose(pos_liquid_front, -1e-1, atol=0.01))\n",
-    "assert(np.isclose(pos_bubble_front, 9e-2, atol=0.01))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/lbmpy_tests/phasefield_allen_cahn/test_phase_field_derivatives.ipynb b/lbmpy_tests/phasefield_allen_cahn/test_phase_field_derivatives.ipynb
index ccb477b70129797a230bbcaf82609055025bdc15..a7180d30d51e59ff37ae514add075aafa0ed5d7d 100644
--- a/lbmpy_tests/phasefield_allen_cahn/test_phase_field_derivatives.ipynb
+++ b/lbmpy_tests/phasefield_allen_cahn/test_phase_field_derivatives.ipynb
@@ -8,6 +8,7 @@
    "source": [
     "from lbmpy.session import *\n",
     "from lbmpy.phasefield_allen_cahn.kernel_equations import *\n",
+    "from lbmpy.phasefield_allen_cahn.parameter_calculation import AllenCahnParameters\n",
     "from pystencils import fields\n",
     "from pystencils import Field\n",
     "\n",
@@ -246,10 +247,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "a = hydrodynamic_force(g, C, lb_method, tau, 1, 0.1, 1, 0, [0, 0, 0] , fd_stencil=None)\n",
-    "b = hydrodynamic_force(g, C, lb_method, tau, 1, 0.1, 1, 0, [0, 0, 0] , fd_stencil=LBStencil(Stencil.D3Q27))\n",
-    "c = hydrodynamic_force(g, C, lb_method, tau, 1, 0.1, 1, 0, [0, 0, 0] , fd_stencil=LBStencil(Stencil.D3Q19))\n",
-    "d = hydrodynamic_force(g, C, lb_method, tau, 1, 0.1, 1, 0, [0, 0, 0] , fd_stencil=LBStencil(Stencil.D3Q15))"
+    "parameters = AllenCahnParameters(density_heavy=1, density_light=0.1,\n",
+    "                                 dynamic_viscosity_heavy=0.016, dynamic_viscosity_light=0.16,\n",
+    "                                 surface_tension=1e-5)"
    ]
   },
   {
@@ -258,13 +258,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "pf = pressure_force(C, stencil, 1, 0.1)\n",
-    "vf = viscous_force(g, C, lb_method, tau, 1, 0.1)\n",
-    "sf = surface_tension_force(C, stencil, 0, 1)\n",
-    "\n",
-    "assert sp.simplify(pf[0] + vf[0] + sf[0] - b[0]) == 0\n",
-    "assert sp.simplify(pf[1] + vf[1] + sf[1] - b[1]) == 0\n",
-    "assert sp.simplify(pf[2] + vf[2] + sf[2] - b[2]) == 0"
+    "a = hydrodynamic_force(g, C, lb_method, parameters, [0, 0, 0] , fd_stencil=None)\n",
+    "b = hydrodynamic_force(g, C, lb_method, parameters, [0, 0, 0] , fd_stencil=LBStencil(Stencil.D3Q27))\n",
+    "c = hydrodynamic_force(g, C, lb_method, parameters, [0, 0, 0] , fd_stencil=LBStencil(Stencil.D3Q19))\n",
+    "d = hydrodynamic_force(g, C, lb_method, parameters, [0, 0, 0] , fd_stencil=LBStencil(Stencil.D3Q15))"
    ]
   },
   {
@@ -273,18 +270,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "stencil = LBStencil(Stencil.D2Q9)\n",
-    "dimensions = len(stencil[0])\n",
-    "C = fields(\"phase_field: [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
-    "g = fields(\"lb_velocity_field(\" + str(len(stencil)) + \"): [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
-    "\n",
-    "tau = 0.53\n",
-    "\n",
-    "lbm_config = LBMConfig(stencil=stencil, method=Method.MRT, relaxation_rates=[1/tau, 1, 1, 1, 1, 1])\n",
-    "lb_method = create_lb_method(lbm_config=lbm_config)\n",
-    "\n",
-    "a = hydrodynamic_force(g, C, lb_method, tau, 1, 0.1, 1, 0, [0, 0, 0] , fd_stencil=None)\n",
-    "b = hydrodynamic_force(g, C, lb_method, tau, 1, 0.1, 1, 0, [0, 0, 0] , fd_stencil=stencil)"
+    "b[0] = b[0].subs(parameters.symbolic_to_numeric_map)\n",
+    "b[1] = b[1].subs(parameters.symbolic_to_numeric_map)\n",
+    "b[2] = b[2].subs(parameters.symbolic_to_numeric_map)"
    ]
   },
   {
@@ -293,21 +281,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "stencil = LBStencil(Stencil.D3Q27)\n",
-    "dimensions = len(stencil[0])\n",
-    "C = fields(\"phase_field: [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
-    "u = fields(\"vel_field(\" + str(dimensions) + \"): [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
-    "h = fields(\"lb_velocity_field(\" + str(len(stencil)) + \"): [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
+    "beta = parameters.beta.subs(parameters.symbolic_to_numeric_map)\n",
+    "kappa = parameters.kappa.subs(parameters.symbolic_to_numeric_map)\n",
     "\n",
-    "tau = 0.53\n",
-    "\n",
-    "lbm_config = LBMConfig(stencil=stencil, method=Method.SRT)\n",
-    "lb_method = create_lb_method(lbm_config=lbm_config)\n",
+    "tau_L = parameters.relaxation_time_light\n",
+    "tau_H = parameters.relaxation_time_heavy\n",
     "\n",
-    "a = initializer_kernel_phase_field_lb(h, C, u, lb_method, 5, fd_stencil=None)\n",
-    "b = initializer_kernel_phase_field_lb(h, C, u, lb_method, 5, fd_stencil=LBStencil(Stencil.D3Q27))\n",
-    "c = initializer_kernel_phase_field_lb(h, C, u, lb_method, 5, fd_stencil=LBStencil(Stencil.D3Q19))\n",
-    "d = initializer_kernel_phase_field_lb(h, C, u, lb_method, 5, fd_stencil=LBStencil(Stencil.D3Q15))"
+    "tau = sp.Rational(1, 2) + tau_L + C.center * (tau_H - tau_L)"
    ]
   },
   {
@@ -315,20 +295,34 @@
    "execution_count": 17,
    "metadata": {},
    "outputs": [],
+   "source": [
+    "pf = pressure_force(C, stencil, 1, 0.1)\n",
+    "vf = viscous_force(g, C, lb_method, tau, 1, 0.1)\n",
+    "sf = surface_tension_force(C, stencil, beta, kappa)\n",
+    "\n",
+    "assert sp.simplify(pf[0] + vf[0] + sf[0] - b[0]) == 0\n",
+    "assert sp.simplify(pf[1] + vf[1] + sf[1] - b[1]) == 0\n",
+    "assert sp.simplify(pf[2] + vf[2] + sf[2] - b[2]) == 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "stencil = LBStencil(Stencil.D2Q9)\n",
     "dimensions = len(stencil[0])\n",
     "C = fields(\"phase_field: [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
-    "u = fields(\"vel_field(\" + str(dimensions) + \"): [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
-    "h = fields(\"lb_velocity_field(\" + str(len(stencil)) + \"): [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
+    "g = fields(\"lb_velocity_field(\" + str(len(stencil)) + \"): [\" + str(dimensions) + \"D]\", layout='fzyx')\n",
     "\n",
     "tau = 0.53\n",
     "\n",
-    "lbm_config = LBMConfig(stencil=stencil, method=Method.SRT)\n",
+    "lbm_config = LBMConfig(stencil=stencil, method=Method.MRT, relaxation_rates=[1/tau, 1, 1, 1, 1, 1])\n",
     "lb_method = create_lb_method(lbm_config=lbm_config)\n",
     "\n",
-    "a = initializer_kernel_phase_field_lb(h, C, u, lb_method, 5, fd_stencil=None)\n",
-    "b = initializer_kernel_phase_field_lb(h, C, u, lb_method, 5, fd_stencil=stencil)"
+    "a = hydrodynamic_force(g, C, lb_method, parameters, [0, 0, 0] , fd_stencil=None)\n",
+    "b = hydrodynamic_force(g, C, lb_method, parameters, [0, 0, 0] , fd_stencil=stencil)"
    ]
   }
  ],
@@ -348,7 +342,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.9.9"
   }
  },
  "nbformat": 4,