collisionLES.cse.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2021 Adrian Kummerlaender
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
*/
 
#ifndef DYNAMICS_COLLISION_LES_CSE_H
#define DYNAMICS_COLLISION_LES_CSE_H
 
 
#ifndef DISABLE_CSE
 
#include "equilibrium.h"
#include "collision.h"
#include "latticeDescriptors.h"
 
namespace olb {
 
namespace collision {
 
namespace detail {
 
template <typename... FIELDS>
struct SmagorinskyEffectiveOmega<BGK,descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x9 = cell[1] + cell[7];
auto x10 = x9 + cell[0] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + V{1};
auto x11 = V{1} / (x10);
auto x14 = V{1}*x11;
auto x15 = -cell[5];
auto x16 = x15 + cell[3];
auto x17 = cell[2] - cell[6];
auto x18 = x16 + x17 + cell[1] - cell[7];
auto x19 = x18*x18;
auto x20 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x21 = -x14*x19 + x20 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x22 = -cell[4] + cell[8];
auto x23 = x15 + x22 + x9 - cell[3];
auto x24 = x23*x23;
auto x25 = -x14*x24 + x20 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x26 = -x11*x18*x23 - x16 + cell[1] - cell[7];
auto x27 = V{1} / (V{3.00000046417339}*util::sqrt(x11*(x13*x13)*util::sqrt(V{0.5}*(x21*x21) + V{0.5}*(x25*x25) + x26*x26) + V{0.0277777691819762}/((x12)*(x12))) + V{0.5}/x12);
auto x28 = V{1} / ((x10)*(x10));
auto x29 = V{1.5}*x28;
auto x30 = x24*x29;
auto x31 = -x18;
auto x32 = x29*(x31*x31) + V{-1};
auto x33 = x30 + x32;
auto x34 = V{1} - x27;
auto x35 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778};
auto x36 = V{4.5}*x28;
auto x37 = x17 + x22 + V{2}*cell[1] - V{2}*cell[5];
auto x38 = x36*(x37*x37);
auto x39 = V{3}*cell[3];
auto x40 = V{3}*cell[7];
auto x41 = V{3}*cell[1] - V{3}*cell[5];
auto x42 = x39 - x40 + x41 + V{3}*cell[2] - V{3}*cell[6];
auto x43 = x11*x42;
auto x44 = -x30 + x43 + V{1};
auto x45 = -x39 + x40 + x41 - V{3}*cell[4] + V{3}*cell[8];
auto x46 = x11*x45;
auto x47 = x19*x29;
auto x48 = x46 - x47;
auto x49 = V{0.111111111111111}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7] + V{0.111111111111111}*cell[8] + V{0.111111111111111};
auto x50 = V{3}*x28;
auto x51 = x17 + V{2}*cell[3] + cell[4] - V{2}*cell[7] - cell[8];
auto x52 = -x51;
auto x53 = x24*x50;
auto x54 = x30 + x43 + V{-1};
auto x55 = x47 + x54;
auto x0 = -x27*(x33*(V{0.444444444444444}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}) + V{0.444444444444444}) + V{1}*x34*cell[0];
auto x1 = x27*(x35*(x38 + x44 + x48) + V{-0.0277777777777778}) + V{1}*x34*cell[1];
auto x2 = x27*(x49*(x19*x50 + x44) + V{-0.111111111111111}) + V{1}*x34*cell[2];
auto x3 = -x27*(x35*(-x11*x42 + x33 - x36*x52*x52 + x46) + V{0.0277777777777778}) + V{1}*x34*cell[3];
auto x4 = -x27*(x49*(x32 + x46 - x53) + V{0.111111111111111}) + V{1}*x34*cell[4];
auto x5 = -x27*(x35*(-x38 + x46 + x55) + V{0.0277777777777778}) + V{1}*x34*cell[5];
auto x6 = x27*(x49*(V{3}*x19*x28 - x54) + V{-0.111111111111111}) + V{1}*x34*cell[6];
auto x7 = x27*(-x35*(-x11*x45 - V{4.5}*x28*x51*x51 + x55) + V{-0.0277777777777778}) + V{1}*x34*cell[7];
auto x8 = x27*(x49*(x48 + x53 + V{1}) + V{-0.111111111111111}) + V{1}*x34*cell[8];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { x10, V{1}*x28*(x19 + x24) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = cell[1] + cell[2];
auto x1 = cell[7] + cell[8];
auto x2 = V{1} / (x0 + x1 + cell[0] + cell[3] + cell[4] + cell[5] + cell[6] + V{1});
auto x3 = V{1}*x2;
auto x4 = -cell[5];
auto x5 = x4 + cell[3];
auto x6 = x0 + x5 - cell[6] - cell[7];
auto x7 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x8 = -x3*x6*x6 + x7 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x9 = x1 + x4 + cell[1] - cell[3] - cell[4];
auto x10 = -x3*x9*x9 + x7 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x11 = -x2*x6*x9 - x5 + cell[1] - cell[7];
return V{1} / (V{3.00000046417339}*util::sqrt(x2*(x13*x13)*util::sqrt(V{0.5}*(x10*x10) + x11*x11 + V{0.5}*(x8*x8)) + V{0.0277777691819762}/((x12)*(x12))) + V{0.5}/x12);
}
 
};
 
template <typename... FIELDS>
struct SmagorinskyEffectiveOmega<BGK,descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x24 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x19 = cell[15] + cell[17];
auto x20 = x19 + cell[12];
auto x21 = cell[11] + cell[18];
auto x22 = cell[10] + cell[14] + cell[16];
auto x25 = cell[2] + cell[8] + cell[9];
auto x26 = cell[13] + cell[3];
auto x27 = x20 + x21 + x22 + x25 + x26 + cell[0] + cell[1] + cell[4] + cell[5] + cell[6] + cell[7] + V{1};
auto x28 = V{1} / (x27);
auto x29 = V{0.333333333333333}*cell[4];
auto x30 = V{0.333333333333333}*cell[5];
auto x31 = V{0.333333333333333}*cell[13];
auto x32 = V{0.333333333333333}*cell[14];
auto x33 = V{1}*x28;
auto x34 = -cell[3];
auto x35 = -cell[18];
auto x36 = -cell[8];
auto x37 = x36 + cell[9];
auto x38 = x34 + x35 + x37;
auto x39 = -cell[6];
auto x40 = x39 + cell[7];
auto x41 = x40 - cell[16];
auto x42 = x20 + x38 + x41;
auto x43 = x42*x42;
auto x44 = V{0.333333333333333}*cell[0];
auto x45 = V{0.333333333333333}*cell[1];
auto x46 = V{0.333333333333333}*cell[10];
auto x47 = x44 + x45 + x46 - V{0.666666666666667}*cell[17] - V{0.666666666666667}*cell[18] - V{0.666666666666667}*cell[8] - V{0.666666666666667}*cell[9];
auto x48 = V{0.333333333333333}*cell[2];
auto x49 = V{0.333333333333333}*cell[11];
auto x50 = x48 + x49 - V{0.666666666666667}*cell[15] - V{0.666666666666667}*cell[16] - V{0.666666666666667}*cell[6] - V{0.666666666666667}*cell[7];
auto x51 = x29 + x30 + x31 + x32 + x33*x43 + x47 + x50 - V{0.666666666666667}*cell[12] - V{0.666666666666667}*cell[3];
auto x52 = V{0.333333333333333}*cell[6];
auto x53 = V{0.333333333333333}*cell[7];
auto x54 = V{0.333333333333333}*cell[15];
auto x55 = V{0.333333333333333}*cell[16];
auto x56 = cell[13] + cell[17];
auto x57 = -cell[2];
auto x58 = -cell[9];
auto x59 = x21 + x36 + x57 + x58;
auto x60 = -cell[4];
auto x61 = x60 + cell[5];
auto x62 = x61 - cell[14];
auto x63 = x56 + x59 + x62;
auto x64 = x63*x63;
auto x65 = V{0.333333333333333}*cell[3];
auto x66 = V{0.333333333333333}*cell[12];
auto x67 = x65 + x66 - V{0.666666666666667}*cell[13] - V{0.666666666666667}*cell[14] - V{0.666666666666667}*cell[4] - V{0.666666666666667}*cell[5];
auto x68 = x33*x64 + x47 + x52 + x53 + x54 + x55 + x67 - V{0.666666666666667}*cell[11] - V{0.666666666666667}*cell[2];
auto x69 = V{0.333333333333333}*cell[8];
auto x70 = V{0.333333333333333}*cell[9];
auto x71 = V{0.333333333333333}*cell[17];
auto x72 = V{0.333333333333333}*cell[18];
auto x73 = cell[13] + cell[15];
auto x74 = -cell[1];
auto x75 = -cell[7];
auto x76 = x39 + x74 + x75;
auto x77 = x60 - cell[5];
auto x78 = x22 + x73 + x76 + x77;
auto x79 = x78*x78;
auto x80 = x33*x79 + x44 + x50 + x67 + x69 + x70 + x71 + x72 - V{0.666666666666667}*cell[10] - V{0.666666666666667}*cell[1];
auto x81 = x28*x78;
auto x82 = x61 + x63*x81 - cell[13] + cell[14];
auto x83 = -cell[15] + cell[16];
auto x84 = x40 + x42*x81 + x83;
auto x85 = -cell[17];
auto x86 = x85 + cell[18];
auto x87 = x28*x42*x63 + x37 + x86;
auto x88 = V{1} / (V{3.00000046417339}*util::sqrt(x28*(x24*x24)*util::sqrt(V{0.5}*(x51*x51) + V{0.5}*(x68*x68) + V{0.5}*(x80*x80) + x82*x82 + x84*x84 + x87*x87) + V{0.0277777691819762}/((x23)*(x23))) + V{0.5}/x23);
auto x89 = V{1} / ((x27)*(x27));
auto x90 = V{1.5}*x89;
auto x91 = x79*x90;
auto x92 = x64*x90;
auto x93 = x43*x90;
auto x94 = x92 + x93 + V{-1};
auto x95 = x91 + x94;
auto x96 = V{1} - x88;
auto x97 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[10] + V{0.0555555555555556}*cell[11] + V{0.0555555555555556}*cell[12] + V{0.0555555555555556}*cell[13] + V{0.0555555555555556}*cell[14] + V{0.0555555555555556}*cell[15] + V{0.0555555555555556}*cell[16] + V{0.0555555555555556}*cell[17] + V{0.0555555555555556}*cell[18] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556}*cell[9] + V{0.0555555555555556};
auto x98 = V{3}*cell[14];
auto x99 = V{3}*cell[16];
auto x100 = V{3}*cell[5];
auto x101 = V{3}*cell[7];
auto x102 = V{3}*cell[13] - V{3}*cell[4];
auto x103 = V{3}*cell[15] - V{3}*cell[6];
auto x104 = x28*(-x100 - x101 + x102 + x103 + x98 + x99 + V{3}*cell[10] - V{3}*cell[1]);
auto x105 = V{3}*x89;
auto x106 = x105*x79;
auto x107 = V{3}*cell[18];
auto x108 = V{3}*cell[9];
auto x109 = V{3}*cell[17] - V{3}*cell[8];
auto x110 = x28*(x100 + x102 + x107 - x108 + x109 - x98 + V{3}*cell[11] - V{3}*cell[2]);
auto x111 = x105*x64;
auto x112 = x91 + V{-1};
auto x113 = x28*(x101 + x103 - x107 + x108 + x109 - x99 + V{3}*cell[12] - V{3}*cell[3]);
auto x114 = x105*x43;
auto x115 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x116 = V{4.5}*x89;
auto x117 = x76 + cell[10] + cell[16];
auto x118 = x117 + x19 + x59 + V{2}*cell[13] - V{2}*cell[4];
auto x119 = x116*(x118*x118);
auto x120 = x104 + x95;
auto x121 = -x110;
auto x122 = x117 + x25 + x35 + x85 - cell[11] + V{2}*cell[14] + cell[15] - V{2}*cell[5];
auto x123 = -x122;
auto x124 = x74 + x77 + cell[10] + cell[14];
auto x125 = x124 + x38 + x56 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x126 = x116*(x125*x125);
auto x127 = -x113;
auto x128 = x26 - cell[12];
auto x129 = x124 + x128 + x58 + x86 + V{2}*cell[16] - V{2}*cell[7] + cell[8];
auto x130 = -x129;
auto x131 = x57 + x62 + cell[11];
auto x132 = x131 + x34 + x41 + x73 + cell[12] + V{2}*cell[17] - V{2}*cell[8];
auto x133 = x116*(x132*x132);
auto x134 = x110 + x95;
auto x135 = x128 + x131 + x75 + x83 + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x136 = -x135;
auto x137 = -x92;
auto x138 = V{1} - x93;
auto x139 = x137 + x138;
auto x140 = x104 + x139;
auto x141 = -x91;
auto x142 = x110 + x141;
auto x143 = x113 + x141;
auto x144 = -x104;
auto x145 = x113 + x95;
cell[0] = -x88*(x95*(x29 + x30 + x31 + x32 + x44 + x45 + x46 + x48 + x49 + x52 + x53 + x54 + x55 + x65 + x66 + x69 + x70 + x71 + x72 + V{0.333333333333333}) + V{0.333333333333333}) + V{1}*x96*cell[0];
cell[1] = -x88*(x97*(x104 - x106 + x94) + V{0.0555555555555556}) + V{1}*x96*cell[1];
cell[2] = -x88*(x97*(x110 - x111 + x112 + x93) + V{0.0555555555555556}) + V{1}*x96*cell[2];
cell[3] = -x88*(x97*(x112 + x113 - x114 + x92) + V{0.0555555555555556}) + V{1}*x96*cell[3];
cell[4] = -x88*(x115*(x110 - x119 + x120) + V{0.0277777777777778}) + V{1}*x96*cell[4];
cell[5] = -x88*(x115*(-x116*x123*x123 + x120 + x121) + V{0.0277777777777778}) + V{1}*x96*cell[5];
cell[6] = -x88*(x115*(x113 + x120 - x126) + V{0.0277777777777778}) + V{1}*x96*cell[6];
cell[7] = -x88*(x115*(-x116*x130*x130 + x120 + x127) + V{0.0277777777777778}) + V{1}*x96*cell[7];
cell[8] = -x88*(x115*(x113 - x133 + x134) + V{0.0277777777777778}) + V{1}*x96*cell[8];
cell[9] = -x88*(x115*(-x116*x136*x136 + x127 + x134) + V{0.0277777777777778}) + V{1}*x96*cell[9];
cell[10] = x88*(x97*(x106 + x140) + V{-0.0555555555555556}) + V{1}*x96*cell[10];
cell[11] = x88*(x97*(x111 + x138 + x142) + V{-0.0555555555555556}) + V{1}*x96*cell[11];
cell[12] = x88*(x97*(x114 + x137 + x143 + V{1}) + V{-0.0555555555555556}) + V{1}*x96*cell[12];
cell[13] = x88*(x115*(x119 + x140 + x142) + V{-0.0277777777777778}) + V{1}*x96*cell[13];
cell[14] = -x88*(x115*(-x116*x122*x122 + x134 + x144) + V{0.0277777777777778}) + V{1}*x96*cell[14];
cell[15] = x88*(x115*(x126 + x140 + x143) + V{-0.0277777777777778}) + V{1}*x96*cell[15];
cell[16] = -x88*(x115*(-x116*x129*x129 + x144 + x145) + V{0.0277777777777778}) + V{1}*x96*cell[16];
cell[17] = x88*(x115*(x113 + x133 + x139 + x142) + V{-0.0277777777777778}) + V{1}*x96*cell[17];
cell[18] = -x88*(x115*(-x116*x135*x135 + x121 + x145) + V{0.0277777777777778}) + V{1}*x96*cell[18];
return { x27, V{1}*x89*(x43 + x64 + x79) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x24 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x0 = cell[12] + cell[15] + cell[17];
auto x1 = cell[11] + cell[13] + cell[18];
auto x2 = cell[10] + cell[14] + cell[16];
auto x3 = V{1} / (x0 + x1 + x2 + cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1});
auto x4 = V{1}*x3;
auto x5 = -cell[6];
auto x6 = x5 + cell[7];
auto x7 = -cell[8];
auto x8 = x7 + cell[9];
auto x9 = x0 + x6 + x8 - cell[16] - cell[18] - cell[3];
auto x10 = V{0.333333333333333}*cell[0];
auto x11 = x10 + V{0.333333333333333}*cell[10] - V{0.666666666666667}*cell[17] - V{0.666666666666667}*cell[18] + V{0.333333333333333}*cell[1] - V{0.666666666666667}*cell[8] - V{0.666666666666667}*cell[9];
auto x12 = V{0.333333333333333}*cell[11] - V{0.666666666666667}*cell[15] - V{0.666666666666667}*cell[16] + V{0.333333333333333}*cell[2] - V{0.666666666666667}*cell[6] - V{0.666666666666667}*cell[7];
auto x13 = x11 + x12 + x4*(x9*x9) - V{0.666666666666667}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] - V{0.666666666666667}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5];
auto x14 = -cell[4];
auto x15 = x14 + cell[5];
auto x16 = x1 + x15 + x7 - cell[14] + cell[17] - cell[2] - cell[9];
auto x17 = V{0.333333333333333}*cell[12] - V{0.666666666666667}*cell[13] - V{0.666666666666667}*cell[14] + V{0.333333333333333}*cell[3] - V{0.666666666666667}*cell[4] - V{0.666666666666667}*cell[5];
auto x18 = x11 + x17 + x4*(x16*x16) - V{0.666666666666667}*cell[11] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] - V{0.666666666666667}*cell[2] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7];
auto x19 = x14 + x2 + x5 + cell[13] + cell[15] - cell[1] - cell[5] - cell[7];
auto x20 = x10 + x12 + x17 + x4*(x19*x19) - V{0.666666666666667}*cell[10] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] - V{0.666666666666667}*cell[1] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9];
auto x21 = x19*x3;
auto x22 = x15 + x16*x21 - cell[13] + cell[14];
auto x25 = x21*x9 + x6 - cell[15] + cell[16];
auto x26 = x16*x3*x9 + x8 - cell[17] + cell[18];
return V{1} / (V{3.00000046417339}*util::sqrt(x3*(x24*x24)*util::sqrt(V{0.5}*(x13*x13) + V{0.5}*(x18*x18) + V{0.5}*(x20*x20) + x22*x22 + x25*x25 + x26*x26) + V{0.0277777691819762}/((x23)*(x23))) + V{0.5}/x23);
}
 
};
 
template <typename... FIELDS>
struct SmagorinskyEffectiveOmega<BGK,descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x32 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x27 = cell[10] + cell[6];
auto x28 = x27 + cell[13];
auto x29 = cell[12] + cell[26];
auto x30 = cell[15] + cell[21];
auto x33 = cell[19] + cell[7];
auto x34 = cell[24] + cell[25];
auto x35 = x34 + cell[14];
auto x36 = x28 + x29 + x30 + x33 + x35 + cell[0] + cell[11] + cell[16] + cell[17] + cell[18] + cell[1] + cell[20] + cell[22] + cell[23] + cell[2] + cell[3] + cell[4] + cell[5] + cell[8] + cell[9] + V{1};
auto x37 = V{1} / (x36);
auto x38 = V{1}*x37;
auto x39 = -cell[24];
auto x40 = -cell[19];
auto x41 = x40 + cell[7];
auto x42 = -cell[25];
auto x43 = x42 + cell[11];
auto x44 = x41 + x43;
auto x45 = -cell[23];
auto x46 = -cell[26];
auto x47 = x45 + x46 + cell[12];
auto x48 = -cell[20];
auto x49 = x48 + cell[4];
auto x50 = -cell[17];
auto x51 = x50 + cell[5];
auto x52 = -cell[14] + cell[1];
auto x53 = x51 + x52 - cell[18];
auto x54 = x28 + x39 + x44 + x47 + x49 + x53;
auto x55 = x54*x54;
auto x56 = V{0.666666666666667}*cell[10];
auto x57 = V{0.666666666666667}*cell[11];
auto x58 = V{0.666666666666667}*cell[12];
auto x59 = V{0.666666666666667}*cell[13];
auto x60 = V{0.666666666666667}*cell[23];
auto x61 = V{0.666666666666667}*cell[24];
auto x62 = V{0.666666666666667}*cell[25];
auto x63 = V{0.666666666666667}*cell[26];
auto x64 = -V{0.333333333333333}*cell[0];
auto x65 = x56 + x57 + x58 + x59 + x60 + x61 + x62 + x63 + x64 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x66 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x67 = -x38*x55 + x65 + x66 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x68 = -cell[12];
auto x69 = x68 + cell[26];
auto x70 = -cell[13];
auto x71 = -cell[21];
auto x72 = x71 + cell[9];
auto x73 = x70 + x72 + cell[11];
auto x74 = x45 + cell[8];
auto x75 = -cell[22];
auto x76 = x75 + cell[4];
auto x77 = -cell[15] + cell[2];
auto x78 = x77 + cell[10];
auto x79 = x50 + cell[18] - cell[5];
auto x80 = x39 + x69 + x73 + x74 + x76 + x78 + x79 + cell[25];
auto x81 = x80*x80;
auto x82 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x83 = -x38*x81 + x65 + x82 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x84 = -cell[11];
auto x85 = -cell[16];
auto x86 = x70 + x85 + cell[3];
auto x87 = -cell[9];
auto x88 = x71 + x87 + cell[22];
auto x89 = x40 + cell[20] - cell[7];
auto x90 = x27 + x29 + x42 + x74 + x84 + x86 + x88 + x89 + cell[24];
auto x91 = x90*x90;
auto x92 = -x38*x91 + x56 + x57 + x58 + x59 + x60 + x61 + x62 + x63 + x64 + x66 + x82 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x93 = -cell[10];
auto x94 = x37*x54;
auto x95 = x39 + cell[12] + cell[26];
auto x96 = x45 + cell[13] + cell[25];
auto x97 = x51 + x80*x94 + x84 + x93 + x95 + x96 + cell[18] - cell[4];
auto x98 = -cell[6];
auto x99 = x45 + cell[13] + cell[24];
auto x100 = x44 + x69 + x90*x94 + x93 + x98 + x99 + cell[20];
auto x101 = -cell[8];
auto x102 = x101 + cell[22];
auto x103 = x102 + x34 + x37*x80*x90 + x47 + x73 + x93;
auto x104 = V{1} / (V{3.00000046417339}*util::sqrt(x37*(x32*x32)*util::sqrt(x100*x100 + x103*x103 + V{0.5}*(x67*x67) + V{0.5}*(x83*x83) + V{0.5}*(x92*x92) + x97*x97) + V{0.0277777691819762}/((x31)*(x31))) + V{0.5}/x31);
auto x105 = V{1} / ((x36)*(x36));
auto x106 = V{1.5}*x105;
auto x107 = -x54;
auto x108 = x107*x107;
auto x109 = x106*x108;
auto x110 = -x80;
auto x111 = x110*x110;
auto x112 = x106*x111;
auto x113 = -x90;
auto x114 = x113*x113;
auto x115 = x106*x114;
auto x116 = x112 + x115 + V{-1};
auto x117 = x109 + x116;
auto x118 = V{1} - x104;
auto x119 = V{0.0740740740740741}*cell[0] + V{0.0740740740740741}*cell[10] + V{0.0740740740740741}*cell[11] + V{0.0740740740740741}*cell[12] + V{0.0740740740740741}*cell[13] + V{0.0740740740740741}*cell[14] + V{0.0740740740740741}*cell[15] + V{0.0740740740740741}*cell[16] + V{0.0740740740740741}*cell[17] + V{0.0740740740740741}*cell[18] + V{0.0740740740740741}*cell[19] + V{0.0740740740740741}*cell[1] + V{0.0740740740740741}*cell[20] + V{0.0740740740740741}*cell[21] + V{0.0740740740740741}*cell[22] + V{0.0740740740740741}*cell[23] + V{0.0740740740740741}*cell[24] + V{0.0740740740740741}*cell[25] + V{0.0740740740740741}*cell[26] + V{0.0740740740740741}*cell[2] + V{0.0740740740740741}*cell[3] + V{0.0740740740740741}*cell[4] + V{0.0740740740740741}*cell[5] + V{0.0740740740740741}*cell[6] + V{0.0740740740740741}*cell[7] + V{0.0740740740740741}*cell[8] + V{0.0740740740740741}*cell[9] + V{0.0740740740740741};
auto x120 = V{3}*cell[5];
auto x121 = V{3}*cell[7];
auto x122 = V{3}*cell[13];
auto x123 = V{3}*cell[18];
auto x124 = V{3}*cell[20];
auto x125 = V{3}*cell[26];
auto x126 = V{3}*cell[10];
auto x127 = V{3}*cell[11];
auto x128 = -V{3}*cell[23];
auto x129 = V{3}*cell[24];
auto x130 = x126 + x127 + x128 - x129 - V{3}*cell[17] + V{3}*cell[4];
auto x131 = V{3}*cell[12];
auto x132 = V{3}*cell[25];
auto x133 = x131 - x132 - V{3}*cell[19] + V{3}*cell[6];
auto x134 = x120 + x121 + x122 - x123 - x124 - x125 + x130 + x133 - V{3}*cell[14] + V{3}*cell[1];
auto x135 = -x134*x37;
auto x136 = V{3}*x105;
auto x137 = V{3}*cell[9];
auto x138 = V{3}*cell[22];
auto x139 = -x122 + x125 - V{3}*cell[21] + V{3}*cell[8];
auto x140 = -x120 + x123 + x130 - x131 + x132 + x137 - x138 + x139 - V{3}*cell[15] + V{3}*cell[2];
auto x141 = -x140*x37;
auto x142 = x109 + V{-1};
auto x143 = -x121 + x124 + x126 - x127 + x128 + x129 + x133 - x137 + x138 + x139 - V{3}*cell[16] + V{3}*cell[3];
auto x144 = -x143*x37;
auto x145 = V{0.0185185185185185}*cell[0] + V{0.0185185185185185}*cell[10] + V{0.0185185185185185}*cell[11] + V{0.0185185185185185}*cell[12] + V{0.0185185185185185}*cell[13] + V{0.0185185185185185}*cell[14] + V{0.0185185185185185}*cell[15] + V{0.0185185185185185}*cell[16] + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[1] + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[23] + V{0.0185185185185185}*cell[24] + V{0.0185185185185185}*cell[25] + V{0.0185185185185185}*cell[26] + V{0.0185185185185185}*cell[2] + V{0.0185185185185185}*cell[3] + V{0.0185185185185185}*cell[4] + V{0.0185185185185185}*cell[5] + V{0.0185185185185185}*cell[6] + V{0.0185185185185185}*cell[7] + V{0.0185185185185185}*cell[8] + V{0.0185185185185185}*cell[9] + V{0.0185185185185185};
auto x146 = V{4.5}*x105;
auto x147 = -V{2}*cell[23];
auto x148 = V{2}*cell[10];
auto x149 = x147 + x148 + cell[8];
auto x150 = V{2}*cell[11] - V{2}*cell[24];
auto x151 = x150 + x77;
auto x152 = x52 - V{2}*cell[17] + V{2}*cell[4];
auto x153 = x41 + x48 + cell[6];
auto x154 = x149 + x151 + x152 + x153 + x72 + x75;
auto x155 = -x154;
auto x156 = x117 + x135;
auto x157 = x141 + x156;
auto x158 = V{2}*cell[25];
auto x159 = V{2}*cell[12];
auto x160 = -x158 + x159;
auto x161 = V{2}*cell[26];
auto x162 = V{2}*cell[13];
auto x163 = -x161 + x162;
auto x164 = V{2}*cell[18];
auto x165 = V{2}*cell[5];
auto x166 = -x164 + x165 + x52 - cell[2];
auto x167 = x102 + x153 + x160 + x163 + x166 + x30 + x87;
auto x168 = -x141;
auto x169 = x156 + x168;
auto x170 = -V{2}*cell[19] + V{2}*cell[6];
auto x171 = x85 + cell[3];
auto x172 = x171 + cell[4];
auto x173 = x149 + x160 + x170 + x172 + x53 + x88;
auto x174 = -x173;
auto x175 = -x144;
auto x176 = V{2}*cell[20];
auto x177 = V{2}*cell[7];
auto x178 = cell[16] - cell[3];
auto x179 = -x176 + x177 + x178;
auto x180 = x101 + x150 + x163 + x179 + x53 + x76 + cell[21] + cell[9];
auto x181 = -V{2}*cell[21] + V{2}*cell[8];
auto x182 = x181 + x77;
auto x183 = x147 + x148 + x161 - x162 + x172 + x182 + x79 + x89 + cell[6];
auto x184 = -x183;
auto x185 = x117 + x141;
auto x186 = x144 + x185;
auto x187 = V{2}*cell[22];
auto x188 = V{2}*cell[9];
auto x189 = -x187 + x188;
auto x190 = x151 + x158 - x159 + x178 + x189 + x33 + x49 + x79 + x98;
auto x191 = V{0.00462962962962963}*cell[0] + V{0.00462962962962963}*cell[10] + V{0.00462962962962963}*cell[11] + V{0.00462962962962963}*cell[12] + V{0.00462962962962963}*cell[13] + V{0.00462962962962963}*cell[14] + V{0.00462962962962963}*cell[15] + V{0.00462962962962963}*cell[16] + V{0.00462962962962963}*cell[17] + V{0.00462962962962963}*cell[18] + V{0.00462962962962963}*cell[19] + V{0.00462962962962963}*cell[1] + V{0.00462962962962963}*cell[20] + V{0.00462962962962963}*cell[21] + V{0.00462962962962963}*cell[22] + V{0.00462962962962963}*cell[23] + V{0.00462962962962963}*cell[24] + V{0.00462962962962963}*cell[25] + V{0.00462962962962963}*cell[26] + V{0.00462962962962963}*cell[2] + V{0.00462962962962963}*cell[3] + V{0.00462962962962963}*cell[4] + V{0.00462962962962963}*cell[5] + V{0.00462962962962963}*cell[6] + V{0.00462962962962963}*cell[7] + V{0.00462962962962963}*cell[8] + V{0.00462962962962963}*cell[9] + V{0.00462962962962963};
auto x192 = x152 + x170 + x182 + x43 + x86 + x95 + V{3}*cell[10] - V{3}*cell[23];
auto x193 = -x192;
auto x194 = x68 + x78;
auto x195 = x152 + x179 + x189 + x194 + x46 + x96 + V{3}*cell[11] - V{3}*cell[24];
auto x196 = x171 + x84;
auto x197 = x166 + x170 + x187 - x188 + x196 + x46 + x99 + cell[10] + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x198 = x134*x37;
auto x199 = x164 - x165 + x176 - x177 + x181 + x194 + x196 + x35 + x45 - V{3}*cell[13] - cell[1] + V{3}*cell[26];
auto x200 = -x199;
auto x201 = x143*x37;
auto x202 = x106*x81;
auto x203 = x106*x91 + V{-1};
auto x204 = x202 + x203;
auto x205 = x140*x37;
auto x206 = x106*x55;
auto x207 = x205 + x206;
auto x208 = x201 + x204 + x207;
auto x209 = x198 + x204;
auto x210 = x201 + x206;
auto x211 = x207 + x209;
auto x212 = -x135;
auto x213 = -x167;
auto x214 = x209 + x210;
auto x215 = -x180;
auto x216 = x117 + x144;
auto x217 = -x190;
auto x218 = -x195;
auto x219 = -x197;
auto x0 = -x104*(x117*(V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296}) + V{0.296296296296296}) + V{1}*x118*cell[0];
auto x1 = -x104*(x119*(-x108*x136 + x116 + x135) + V{0.0740740740740741}) + V{1}*x118*cell[1];
auto x2 = -x104*(x119*(-x111*x136 + x115 + x141 + x142) + V{0.0740740740740741}) + V{1}*x118*cell[2];
auto x3 = -x104*(x119*(x112 - x114*x136 + x142 + x144) + V{0.0740740740740741}) + V{1}*x118*cell[3];
auto x4 = -x104*(x145*(-x146*x155*x155 + x157) + V{0.0185185185185185}) + V{1}*x118*cell[4];
auto x5 = -x104*(x145*(-x146*x167*x167 + x169) + V{0.0185185185185185}) + V{1}*x118*cell[5];
auto x6 = -x104*(x145*(x144 - x146*x174*x174 + x156) + V{0.0185185185185185}) + V{1}*x118*cell[6];
auto x7 = -x104*(x145*(-x146*x180*x180 + x156 + x175) + V{0.0185185185185185}) + V{1}*x118*cell[7];
auto x8 = -x104*(x145*(-x146*x184*x184 + x186) + V{0.0185185185185185}) + V{1}*x118*cell[8];
auto x9 = -x104*(x145*(-x146*x190*x190 + x175 + x185) + V{0.0185185185185185}) + V{1}*x118*cell[9];
auto x10 = -x104*(x191*(x144 - x146*x193*x193 + x157) + V{0.00462962962962963}) + V{1}*x118*cell[10];
auto x11 = -x104*(x191*(-x146*x195*x195 + x157 + x175) + V{0.00462962962962963}) + V{1}*x118*cell[11];
auto x12 = -x104*(x191*(x144 - x146*x197*x197 + x169) + V{0.00462962962962963}) + V{1}*x118*cell[12];
auto x13 = -x104*(x191*(-x146*x200*x200 - x198 + x208) + V{0.00462962962962963}) + V{1}*x118*cell[13];
auto x14 = -x104*(x119*(-x136*x55 + x209) + V{0.0740740740740741}) + V{1}*x118*cell[14];
auto x15 = -x104*(x119*(-x136*x81 + x203 + x207) + V{0.0740740740740741}) + V{1}*x118*cell[15];
auto x16 = -x104*(x119*(-x136*x91 + x202 + x210 + V{-1}) + V{0.0740740740740741}) + V{1}*x118*cell[16];
auto x17 = -x104*(x145*(-x146*x154*x154 + x211) + V{0.0185185185185185}) + V{1}*x118*cell[17];
auto x18 = -x104*(x145*(-x146*x213*x213 + x185 + x212) + V{0.0185185185185185}) + V{1}*x118*cell[18];
auto x19 = -x104*(x145*(-x146*x173*x173 + x214) + V{0.0185185185185185}) + V{1}*x118*cell[19];
auto x20 = -x104*(x145*(-x146*x215*x215 + x212 + x216) + V{0.0185185185185185}) + V{1}*x118*cell[20];
auto x21 = -x104*(x145*(-x146*x183*x183 + x208) + V{0.0185185185185185}) + V{1}*x118*cell[21];
auto x22 = -x104*(x145*(-x146*x217*x217 + x168 + x216) + V{0.0185185185185185}) + V{1}*x118*cell[22];
auto x23 = -x104*(x191*(-x146*x192*x192 + x201 + x211) + V{0.00462962962962963}) + V{1}*x118*cell[23];
auto x24 = -x104*(x191*(-x146*x218*x218 - x201 + x211) + V{0.00462962962962963}) + V{1}*x118*cell[24];
auto x25 = -x104*(x191*(-x146*x219*x219 - x205 + x214) + V{0.00462962962962963}) + V{1}*x118*cell[25];
auto x26 = -x104*(x191*(-x146*x199*x199 + x186 + x212) + V{0.00462962962962963}) + V{1}*x118*cell[26];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { x36, V{1}*x105*(x55 + x81 + x91) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x32 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = cell[12] + cell[25];
auto x1 = x0 + cell[18];
auto x2 = cell[11] + cell[24];
auto x3 = x2 + cell[20];
auto x4 = cell[22] + cell[9];
auto x5 = cell[13] + cell[1];
auto x6 = cell[26] + cell[2] + cell[8];
auto x7 = cell[10] + cell[3];
auto x8 = V{1} / (x1 + x3 + x4 + x5 + x6 + x7 + cell[0] + cell[14] + cell[15] + cell[16] + cell[17] + cell[19] + cell[21] + cell[23] + cell[4] + cell[5] + cell[6] + cell[7] + V{1});
auto x9 = V{1}*x8;
auto x10 = -cell[17];
auto x11 = -cell[24];
auto x12 = x10 + x11 + cell[5];
auto x13 = -cell[19];
auto x14 = -cell[25];
auto x15 = x13 + x14 + cell[7];
auto x16 = -cell[23];
auto x17 = x16 - cell[26];
auto x18 = cell[10] + cell[11] + cell[4];
auto x19 = cell[12] + cell[6];
auto x20 = x12 + x15 + x17 + x18 + x19 + x5 - cell[14] - cell[18] - cell[20];
auto x21 = V{0.666666666666667}*cell[10];
auto x22 = V{0.666666666666667}*cell[11];
auto x23 = V{0.666666666666667}*cell[12];
auto x24 = V{0.666666666666667}*cell[13];
auto x25 = V{0.666666666666667}*cell[23];
auto x26 = V{0.666666666666667}*cell[24];
auto x27 = V{0.666666666666667}*cell[25];
auto x28 = V{0.666666666666667}*cell[26];
auto x29 = -V{0.333333333333333}*cell[0];
auto x30 = x21 + x22 + x23 + x24 + x25 + x26 + x27 + x28 + x29 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x33 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x34 = x30 + x33 - x9*x20*x20 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x35 = -cell[12];
auto x36 = -cell[13] - cell[21];
auto x37 = x16 + x36;
auto x38 = x10 + x11 + x18 + x35 + x37 + x6 - cell[15] + cell[18] - cell[22] + cell[25] - cell[5] + cell[9];
auto x39 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x40 = x30 + x39 - x9*x38*x38 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x41 = -cell[11];
auto x42 = x13 + x14 + x19 + x37 + x41 + x7 - cell[16] + cell[20] + cell[22] + cell[24] + cell[26] - cell[7] + cell[8] - cell[9];
auto x43 = x21 + x22 + x23 + x24 + x25 + x26 + x27 + x28 + x29 + x33 + x39 - x9*x42*x42 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x44 = x20*x8;
auto x45 = -cell[10];
auto x46 = x16 + x45 + cell[13] + cell[26];
auto x47 = x1 + x12 + x38*x44 + x41 + x46 - cell[4];
auto x48 = x15 + x3 + x35 + x42*x44 + x46 - cell[6];
auto x49 = x0 + x17 + x2 + x36 + x38*x42*x8 + x4 + x45 - cell[8];
return V{1} / (V{3.00000046417339}*util::sqrt(x8*(x32*x32)*util::sqrt(V{0.5}*(x34*x34) + V{0.5}*(x40*x40) + V{0.5}*(x43*x43) + x47*x47 + x48*x48 + x49*x49) + V{0.0277777691819762}/((x31)*(x31))) + V{0.5}/x31);
}
 
};
 
 
template <typename... FIELDS>
struct SmagorinskyEffectiveOmega<BGK,descriptors::D2Q9<FIELDS...>,momenta::ForcedWithStress<momenta::BulkTuple>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x9 = cell.template getFieldComponent<olb::descriptors::FORCE>(0);
auto x10 = cell.template getFieldComponent<olb::descriptors::FORCE>(1);
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x11 = cell[7] + cell[8];
auto x14 = cell[2] + cell[3];
auto x15 = x11 + x14 + cell[0] + cell[1] + cell[4] + cell[5] + cell[6];
auto x16 = x15 + V{1};
auto x17 = V{1} / (x16);
auto x18 = V{1}*cell[5];
auto x19 = -V{1}*cell[7];
auto x20 = cell[1] - cell[5];
auto x21 = x14 + x20 - cell[6] - cell[7];
auto x22 = x11 + x20 - cell[3] - cell[4];
auto x23 = x15 + V{1};
auto x24 = x23*(x10*x21 - x22*x9);
auto x25 = V{1}*cell[1];
auto x26 = V{1}*cell[3];
auto x27 = x25 - x26;
auto x28 = x17*x23;
auto x29 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x30 = -x17*x21*x21 - x21*x28*x9 + x29 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x31 = x10*x22*x28 - x17*x22*x22 + x29 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x32 = V{1} / (V{2.52268963608289}*util::sqrt(x17*(x13*x13)*util::sqrt((V{1}*x17*x21*x22 - V{0.5}*x17*x24 - x18 - x19 - x27)*(V{2}*x17*x21*x22 - V{1}*x17*x24 - V{2}*cell[1] + V{2}*cell[3] - V{2}*cell[5] + V{2}*cell[7]) + x30*x30 + x31*x31) + V{0.0392836979096202}/((x12)*(x12))) + V{0.5}/x12);
auto x33 = V{1}*cell[7];
auto x34 = V{1}*cell[8];
auto x35 = V{1}*cell[4];
auto x36 = -x18;
auto x37 = V{0.5}*x10 + x17*(x27 + x33 + x34 - x35 + x36);
auto x38 = x37*x37;
auto x39 = V{1.5}*x38;
auto x40 = V{0.5}*x9;
auto x41 = V{1}*cell[2];
auto x42 = x19 + x25 + x26 + x36 + x41 - V{1}*cell[6];
auto x43 = -x42;
auto x44 = x17*x43 + x40;
auto x45 = x39 + V{-1} + V{1.5}*(x44*x44);
auto x46 = V{1} - x32;
auto x47 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778};
auto x48 = V{1.5}*x9;
auto x49 = -x48;
auto x50 = V{3}*cell[3];
auto x51 = V{3}*cell[7];
auto x52 = V{3}*cell[1] - V{3}*cell[5];
auto x53 = x50 - x51 + x52 + V{3}*cell[2] - V{3}*cell[6];
auto x54 = x17*x53;
auto x55 = x17*x42;
auto x56 = x37 - x40;
auto x57 = V{4.5}*cell[3];
auto x58 = V{4.5}*cell[7];
auto x59 = V{4.5}*cell[1] - V{4.5}*cell[5];
auto x60 = x57 - x58 + x59 + V{4.5}*cell[2] - V{4.5}*cell[6];
auto x61 = x17*x60;
auto x62 = V{2.25}*x9;
auto x63 = V{2.25}*x10 + x17*(-x57 + x58 + x59 - V{4.5}*cell[4] + V{4.5}*cell[8]);
auto x64 = -x62 + x63;
auto x65 = V{1.5}*x10 + x17*(-x50 + x51 + x52 - V{3}*cell[4] + V{3}*cell[8]);
auto x66 = x40 - x55;
auto x67 = x66*x66;
auto x68 = -x39 - V{1.5}*x67 + V{1};
auto x69 = x65 + x68;
auto x70 = V{0.111111111111111}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7] + V{0.111111111111111}*cell[8] + V{0.111111111111111};
auto x71 = -x60;
auto x72 = x17*x71 + x62;
auto x73 = -x17*x53;
auto x74 = x45 + x48 + x73;
auto x75 = x37*x63;
auto x76 = x45 + x65;
auto x77 = -x61 + x62;
auto x78 = x48 - x54 + x68;
auto x0 = -x32*(x45*(V{0.444444444444444}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}) + V{0.444444444444444}) + V{1}*x46*cell[0];
auto x1 = x25*x46 + x32*(x47*(x49 + x54 + x69 + (x55 + x56)*(x61 + x64)) + V{-0.0277777777777778});
auto x2 = -x32*(x70*(-x44*x72 + x74) + V{0.111111111111111}) + x41*x46;
auto x3 = x26*x46 - x32*(x47*(x65 + x74 - (x37 + x44)*(x63 + x72)) + V{0.0277777777777778});
auto x4 = -x32*(x70*(-x75 + x76) + V{0.111111111111111}) + x35*x46;
auto x5 = x18*x46 - x32*(x47*(x49 - x73 + x76 - (x17*x43 - x56)*(x17*x71 - x64)) + V{0.0277777777777778});
auto x6 = x32*(x70*(x66*x77 + x78) + V{-0.111111111111111}) + V{1}*x46*cell[6];
auto x7 = x32*(x47*(x65 + x78 + (x37 + x66)*(x63 + x77)) + V{-0.0277777777777778}) + x33*x46;
auto x8 = x32*(x70*(x69 + x75) + V{-0.111111111111111}) + x34*x46;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { x16, x38 + x67 };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x9 = cell.template getFieldComponent<olb::descriptors::FORCE>(0);
auto x10 = cell.template getFieldComponent<olb::descriptors::FORCE>(1);
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = cell[7] + cell[8];
auto x1 = cell[2] + cell[3];
auto x2 = x0 + x1 + cell[0] + cell[1] + cell[4] + cell[5] + cell[6];
auto x3 = V{1} / (x2 + V{1});
auto x4 = cell[1] - cell[5];
auto x5 = x1 + x4 - cell[6] - cell[7];
auto x6 = x0 + x4 - cell[3] - cell[4];
auto x7 = x2 + V{1};
auto x8 = x7*(x10*x5 - x6*x9);
auto x11 = x3*x7;
auto x14 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x15 = -x11*x5*x9 + x14 - x3*x5*x5 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x16 = x10*x11*x6 + x14 - x3*x6*x6 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
return V{1} / (V{2.52268963608289}*util::sqrt(x3*(x13*x13)*util::sqrt((V{1}*x3*x5*x6 - V{0.5}*x3*x8 - V{1}*cell[1] + V{1}*cell[3] - V{1}*cell[5] + V{1}*cell[7])*(V{2}*x3*x5*x6 - V{1}*x3*x8 - V{2}*cell[1] + V{2}*cell[3] - V{2}*cell[5] + V{2}*cell[7]) + x15*x15 + x16*x16) + V{0.0392836979096202}/((x12)*(x12))) + V{0.5}/x12);
}
 
};
 
template <typename... FIELDS>
struct SmagorinskyEffectiveOmega<BGK,descriptors::D3Q19<FIELDS...>,momenta::ForcedWithStress<momenta::BulkTuple>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x19 = cell.template getFieldComponent<olb::descriptors::FORCE>(0);
auto x20 = cell.template getFieldComponent<olb::descriptors::FORCE>(1);
auto x21 = cell.template getFieldComponent<olb::descriptors::FORCE>(2);
auto x24 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x22 = cell[12] + cell[7] + cell[9];
auto x25 = cell[10] + cell[14] + cell[16];
auto x26 = cell[11] + cell[18] + cell[5];
auto x27 = x22 + x25 + x26 + cell[0] + cell[13] + cell[15] + cell[17] + cell[1] + cell[2] + cell[3] + cell[4] + cell[6] + cell[8];
auto x28 = x27 + V{1};
auto x29 = V{1} / (x28);
auto x30 = V{1}*cell[6];
auto x31 = V{1}*cell[16];
auto x32 = -x31;
auto x33 = cell[15] - cell[6];
auto x34 = cell[17] - cell[8];
auto x35 = x22 + x33 + x34 - cell[16] - cell[18] - cell[3];
auto x36 = cell[13] - cell[4];
auto x37 = x25 + x33 + x36 - cell[1] - cell[5] - cell[7];
auto x38 = x29*(x27 + V{1});
auto x39 = V{0.5}*x38;
auto x40 = x29*x37;
auto x41 = V{1}*x40;
auto x42 = V{1}*cell[15];
auto x43 = V{1}*cell[7];
auto x44 = x42 - x43;
auto x45 = x30 + x32 - x35*x41 + x39*(x19*x35 + x21*x37) + x44;
auto x46 = V{1}*cell[4];
auto x47 = V{1}*cell[14];
auto x48 = -x47;
auto x49 = x26 + x34 + x36 - cell[14] - cell[2] - cell[9];
auto x50 = x19*x49 + x20*x37;
auto x51 = V{1}*cell[13];
auto x52 = V{1}*cell[5];
auto x53 = x51 - x52;
auto x54 = V{1}*x38;
auto x55 = V{2}*x49;
auto x56 = V{1}*cell[8];
auto x57 = V{1}*cell[18];
auto x58 = -x57;
auto x59 = x20*x35 + x21*x49;
auto x60 = x29*x35;
auto x61 = V{1}*cell[17];
auto x62 = V{1}*cell[9];
auto x63 = x61 - x62;
auto x64 = V{0.333333333333333}*cell[8];
auto x65 = V{0.333333333333333}*cell[9];
auto x66 = V{0.333333333333333}*cell[17];
auto x67 = V{0.333333333333333}*cell[18];
auto x68 = V{0.333333333333333}*cell[0];
auto x69 = -x68;
auto x70 = V{0.333333333333333}*cell[3];
auto x71 = V{0.333333333333333}*cell[12];
auto x72 = x69 - x70 - x71 + V{0.666666666666667}*cell[13] + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x73 = V{0.333333333333333}*cell[2];
auto x74 = V{0.333333333333333}*cell[11];
auto x75 = -x73 - x74 + V{0.666666666666667}*cell[15] + V{0.666666666666667}*cell[16] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x76 = x19*x37*x38 - x29*x37*x37 - x64 - x65 - x66 - x67 + x72 + x75 + V{0.666666666666667}*cell[10] + V{0.666666666666667}*cell[1];
auto x77 = V{0.333333333333333}*cell[6];
auto x78 = V{0.333333333333333}*cell[7];
auto x79 = V{0.333333333333333}*cell[15];
auto x80 = V{0.333333333333333}*cell[16];
auto x81 = V{0.333333333333333}*cell[1];
auto x82 = V{0.333333333333333}*cell[10];
auto x83 = -x81 - x82 + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x84 = x20*x38*x49 - x29*x49*x49 + x72 - x77 - x78 - x79 - x80 + x83 + V{0.666666666666667}*cell[11] + V{0.666666666666667}*cell[2];
auto x85 = V{0.333333333333333}*cell[4];
auto x86 = V{0.333333333333333}*cell[5];
auto x87 = V{0.333333333333333}*cell[13];
auto x88 = V{0.333333333333333}*cell[14];
auto x89 = x21*x35*x38 - x29*x35*x35 + x69 + x75 + x83 - x85 - x86 - x87 - x88 + V{0.666666666666667}*cell[12] + V{0.666666666666667}*cell[3];
auto x90 = V{1} / (V{3.00000046417339}*util::sqrt(x29*(x24*x24)*util::sqrt(V{0.5}*(x39*x50 - x41*x49 + x46 + x48 + x53)*(-x40*x55 + x50*x54 + V{2}*cell[13] - V{2}*cell[14] + V{2}*cell[4] - V{2}*cell[5]) + V{0.5}*(x39*x59 - V{1}*x49*x60 + x56 + x58 + x63)*(x54*x59 - x55*x60 + V{2}*cell[17] - V{2}*cell[18] + V{2}*cell[8] - V{2}*cell[9]) + x45*x45 + V{0.5}*(x76*x76) + V{0.5}*(x84*x84) + V{0.5}*(x89*x89)) + V{0.0277777691819762}/((x23)*(x23))) + V{0.5}/x23);
auto x91 = V{1}*cell[10];
auto x92 = V{1}*cell[1];
auto x93 = -x46;
auto x94 = -x30;
auto x95 = V{0.5}*x19 + x29*(x31 + x44 + x47 + x53 + x91 - x92 + x93 + x94);
auto x96 = x95*x95;
auto x97 = V{1.5}*x96;
auto x98 = V{0.5}*x20;
auto x99 = V{1}*cell[11];
auto x100 = V{1}*cell[2];
auto x101 = -x56;
auto x102 = x29*(-x100 + x101 + x48 + x51 + x52 + x57 + x63 + x93 + x99);
auto x103 = x102 + x98;
auto x104 = x103*x103;
auto x105 = V{1.5}*x104;
auto x106 = V{1}*cell[12];
auto x107 = V{1}*cell[3];
auto x108 = x101 + x106 - x107 + x32 + x42 + x43 + x58 + x61 + x62 + x94;
auto x109 = x108*x29 + V{0.5}*x21;
auto x110 = x109*x109;
auto x111 = V{1.5}*x110;
auto x112 = x105 + x111 + x97 + V{-1};
auto x113 = V{1} - x90;
auto x114 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[10] + V{0.0555555555555556}*cell[11] + V{0.0555555555555556}*cell[12] + V{0.0555555555555556}*cell[13] + V{0.0555555555555556}*cell[14] + V{0.0555555555555556}*cell[15] + V{0.0555555555555556}*cell[16] + V{0.0555555555555556}*cell[17] + V{0.0555555555555556}*cell[18] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556}*cell[9] + V{0.0555555555555556};
auto x115 = V{4.5}*cell[14];
auto x116 = V{4.5}*cell[16];
auto x117 = V{4.5}*cell[5];
auto x118 = V{4.5}*cell[7];
auto x119 = V{4.5}*cell[13] - V{4.5}*cell[4];
auto x120 = V{4.5}*cell[15] - V{4.5}*cell[6];
auto x121 = V{2.25}*x19 + x29*(x115 + x116 - x117 - x118 + x119 + x120 + V{4.5}*cell[10] - V{4.5}*cell[1]);
auto x122 = x121*x95;
auto x123 = V{1.5}*x19;
auto x124 = V{3}*cell[14];
auto x125 = V{3}*cell[16];
auto x126 = V{3}*cell[5];
auto x127 = V{3}*cell[7];
auto x128 = V{3}*cell[13] - V{3}*cell[4];
auto x129 = V{3}*cell[15] - V{3}*cell[6];
auto x130 = x29*(x124 + x125 - x126 - x127 + x128 + x129 + V{3}*cell[10] - V{3}*cell[1]);
auto x131 = x123 + x130;
auto x132 = x112 + x131;
auto x133 = V{2.25}*x20;
auto x134 = V{4.5}*cell[18];
auto x135 = V{4.5}*cell[9];
auto x136 = V{4.5}*cell[17] - V{4.5}*cell[8];
auto x137 = x29*(-x115 + x117 + x119 + x134 - x135 + x136 + V{4.5}*cell[11] - V{4.5}*cell[2]);
auto x138 = x133 + x137;
auto x139 = x103*x138;
auto x140 = V{1.5}*x20;
auto x141 = V{3}*cell[18];
auto x142 = V{3}*cell[9];
auto x143 = V{3}*cell[17] - V{3}*cell[8];
auto x144 = x29*(-x124 + x126 + x128 + x141 - x142 + x143 + V{3}*cell[11] - V{3}*cell[2]);
auto x145 = x140 + x144;
auto x146 = x112 + x145;
auto x147 = -x116 + x118 + x120 - x134 + x135 + x136 + V{4.5}*cell[12] - V{4.5}*cell[3];
auto x148 = x147*x29 + V{2.25}*x21;
auto x149 = x109*x148;
auto x150 = V{1.5}*x21;
auto x151 = x29*(-x125 + x127 + x129 - x141 + x142 + x143 + V{3}*cell[12] - V{3}*cell[3]);
auto x152 = x150 + x151;
auto x153 = x112 + x152;
auto x154 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x155 = (x103 + x95)*(x121 + x138);
auto x156 = -x102 + x95 - x98;
auto x157 = x121 - x133 - x137;
auto x158 = -x140 - x144;
auto x159 = (x109 + x95)*(x121 + x148);
auto x160 = -x108*x29 - V{0.5}*x21;
auto x161 = x160 + x95;
auto x162 = -x147*x29 - V{2.25}*x21;
auto x163 = x121 + x162;
auto x164 = -x150 - x151;
auto x165 = (x103 + x109)*(x138 + x148);
auto x166 = x103 + x160;
auto x167 = x138 + x162;
auto x168 = -x105 - x111 - x97 + V{1};
auto x169 = x131 + x168;
auto x170 = x145 + x168;
auto x171 = -x123 - x130;
cell[0] = V{1}*x113*cell[0] - x90*(x112*(x64 + x65 + x66 + x67 + x68 + x70 + x71 + x73 + x74 + x77 + x78 + x79 + x80 + x81 + x82 + x85 + x86 + x87 + x88 + V{0.333333333333333}) + V{0.333333333333333});
cell[1] = x113*x92 - x90*(x114*(-x122 + x132) + V{0.0555555555555556});
cell[2] = x100*x113 - x90*(x114*(-x139 + x146) + V{0.0555555555555556});
cell[3] = x107*x113 - x90*(x114*(-x149 + x153) + V{0.0555555555555556});
cell[4] = x113*x46 - x90*(x154*(x132 + x145 - x155) + V{0.0277777777777778});
cell[5] = x113*x52 - x90*(x154*(x132 - x156*x157 + x158) + V{0.0277777777777778});
cell[6] = x113*x30 - x90*(x154*(x132 + x152 - x159) + V{0.0277777777777778});
cell[7] = x113*x43 - x90*(x154*(x132 - x161*x163 + x164) + V{0.0277777777777778});
cell[8] = x113*x56 - x90*(x154*(x146 + x152 - x165) + V{0.0277777777777778});
cell[9] = x113*x62 - x90*(x154*(x146 + x164 - x166*x167) + V{0.0277777777777778});
cell[10] = x113*x91 + x90*(x114*(x122 + x169) + V{-0.0555555555555556});
cell[11] = x113*x99 + x90*(x114*(x139 + x170) + V{-0.0555555555555556});
cell[12] = x106*x113 + x90*(x114*(x149 + x152 + x168) + V{-0.0555555555555556});
cell[13] = x113*x51 + x90*(x154*(x145 + x155 + x169) + V{-0.0277777777777778});
cell[14] = x113*x47 - x90*(x154*(x146 - x156*x157 + x171) + V{0.0277777777777778});
cell[15] = x113*x42 + x90*(x154*(x152 + x159 + x169) + V{-0.0277777777777778});
cell[16] = x113*x31 - x90*(x154*(x153 - x161*x163 + x171) + V{0.0277777777777778});
cell[17] = x113*x61 + x90*(x154*(x152 + x165 + x170) + V{-0.0277777777777778});
cell[18] = x113*x57 - x90*(x154*(x153 + x158 - x166*x167) + V{0.0277777777777778});
return { x28, x104 + x110 + x96 };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x19 = cell.template getFieldComponent<olb::descriptors::FORCE>(0);
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x24 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x20 = cell.template getFieldComponent<olb::descriptors::FORCE>(1);
auto x21 = cell.template getFieldComponent<olb::descriptors::FORCE>(2);
auto x0 = cell[12] + cell[7] + cell[9];
auto x1 = cell[10] + cell[14] + cell[16];
auto x2 = cell[11] + cell[18] + cell[5];
auto x3 = x0 + x1 + x2 + cell[0] + cell[13] + cell[15] + cell[17] + cell[1] + cell[2] + cell[3] + cell[4] + cell[6] + cell[8];
auto x4 = V{1} / (x3 + V{1});
auto x5 = cell[15] - cell[6];
auto x6 = cell[17] - cell[8];
auto x7 = x0 + x5 + x6 - cell[16] - cell[18] - cell[3];
auto x8 = cell[13] - cell[4];
auto x9 = x1 + x5 + x8 - cell[1] - cell[5] - cell[7];
auto x10 = x4*(x3 + V{1});
auto x11 = V{0.5}*x10;
auto x12 = x4*x9;
auto x13 = V{1}*x12;
auto x14 = x11*(x19*x7 + x21*x9) - x13*x7 + V{1}*cell[15] - V{1}*cell[16] + V{1}*cell[6] - V{1}*cell[7];
auto x15 = x2 + x6 + x8 - cell[14] - cell[2] - cell[9];
auto x16 = x15*x19 + x20*x9;
auto x17 = V{1}*x10;
auto x18 = V{2}*x15;
auto x22 = x15*x21 + x20*x7;
auto x25 = x4*x7;
auto x26 = -V{0.333333333333333}*cell[0];
auto x27 = x26 - V{0.333333333333333}*cell[12] + V{0.666666666666667}*cell[13] + V{0.666666666666667}*cell[14] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x28 = -V{0.333333333333333}*cell[11] + V{0.666666666666667}*cell[15] + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x29 = x10*x19*x9 + x27 + x28 - x4*x9*x9 + V{0.666666666666667}*cell[10] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x30 = -V{0.333333333333333}*cell[10] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x31 = x10*x15*x20 + x27 + x30 - x4*x15*x15 + V{0.666666666666667}*cell[11] - V{0.333333333333333}*cell[15] - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x32 = x10*x21*x7 + x26 + x28 + x30 - x4*x7*x7 + V{0.666666666666667}*cell[12] - V{0.333333333333333}*cell[13] - V{0.333333333333333}*cell[14] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
return V{1} / (V{2.52268963608289}*util::sqrt(x4*(x24*x24)*util::sqrt((x11*x16 - x13*x15 + V{1}*cell[13] - V{1}*cell[14] + V{1}*cell[4] - V{1}*cell[5])*(-x12*x18 + x16*x17 + V{2}*cell[13] - V{2}*cell[14] + V{2}*cell[4] - V{2}*cell[5]) + (x11*x22 - V{1}*x15*x25 + V{1}*cell[17] - V{1}*cell[18] + V{1}*cell[8] - V{1}*cell[9])*(x17*x22 - x18*x25 + V{2}*cell[17] - V{2}*cell[18] + V{2}*cell[8] - V{2}*cell[9]) + 2*(x14*x14) + x29*x29 + x31*x31 + x32*x32) + V{0.0392836979096202}/((x23)*(x23))) + V{0.5}/x23);
}
 
};
 
template <typename... FIELDS>
struct SmagorinskyEffectiveOmega<BGK,descriptors::D3Q27<FIELDS...>,momenta::ForcedWithStress<momenta::BulkTuple>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x27 = cell.template getFieldComponent<olb::descriptors::FORCE>(0);
auto x28 = cell.template getFieldComponent<olb::descriptors::FORCE>(1);
auto x29 = cell.template getFieldComponent<olb::descriptors::FORCE>(2);
auto x32 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x30 = cell[20] + cell[22] + cell[24] + cell[3];
auto x33 = cell[13] + cell[1] + cell[5] + cell[7];
auto x34 = cell[10] + cell[18] + cell[25] + cell[2] + cell[9];
auto x35 = x30 + x33 + x34 + cell[0] + cell[11] + cell[12] + cell[14] + cell[15] + cell[16] + cell[17] + cell[19] + cell[21] + cell[23] + cell[26] + cell[4] + cell[6] + cell[8];
auto x36 = x35 + V{1};
auto x37 = V{1} / (x36);
auto x38 = V{1}*cell[20];
auto x39 = V{1}*cell[6];
auto x40 = V{1}*cell[12];
auto x41 = -x40;
auto x42 = -cell[23];
auto x43 = x42 + cell[10] + cell[12] - cell[19] - cell[25] + cell[6];
auto x44 = -cell[13] - cell[21] + cell[26] + cell[8];
auto x45 = x30 + x43 + x44 - cell[11] - cell[16] - cell[7] - cell[9];
auto x46 = cell[11] - cell[17] - cell[24] + cell[4];
auto x47 = x33 + x43 + x46 - cell[14] - cell[18] - cell[20] - cell[26];
auto x48 = x37*(x35 + V{1});
auto x49 = V{0.5}*x48;
auto x50 = x37*x47;
auto x51 = V{1}*x50;
auto x52 = V{1}*cell[13];
auto x53 = V{1}*cell[26];
auto x54 = V{1}*cell[10];
auto x55 = -x54;
auto x56 = -V{1}*cell[23];
auto x57 = x52 + x53 + x55 + x56;
auto x58 = V{1}*cell[11];
auto x59 = V{1}*cell[24];
auto x60 = x58 + x59;
auto x61 = V{1}*cell[7];
auto x62 = -V{1}*cell[19];
auto x63 = V{1}*cell[25];
auto x64 = -x63;
auto x65 = x61 + x62 + x64;
auto x66 = -x38 + x39 - x41 - x45*x51 - x49*(x27*x45 + x29*x47) - x57 - x60 - x65;
auto x67 = V{1}*cell[18];
auto x68 = V{1}*cell[4];
auto x69 = -x58;
auto x70 = x34 + x42 + x44 + x46 - cell[12] - cell[15] - cell[22] - cell[5];
auto x71 = x27*x70 + x28*x47;
auto x72 = x40 + x63;
auto x73 = V{1}*cell[5];
auto x74 = -V{1}*cell[17];
auto x75 = -x59;
auto x76 = x73 + x74 + x75;
auto x77 = V{2}*cell[13];
auto x78 = V{2}*cell[26];
auto x79 = V{2}*cell[11];
auto x80 = V{2}*cell[24];
auto x81 = V{1}*x48;
auto x82 = V{2}*x70;
auto x83 = -V{2}*cell[10] + V{2}*cell[12] - V{2}*cell[23] + V{2}*cell[25];
auto x84 = V{1}*cell[22];
auto x85 = V{1}*cell[8];
auto x86 = x28*x45 + x29*x70;
auto x87 = x37*x45;
auto x88 = -x53 + x56;
auto x89 = V{1}*cell[9];
auto x90 = -x52;
auto x91 = -V{1}*cell[21];
auto x92 = x89 + x90 + x91;
auto x93 = V{0.666666666666667}*cell[10];
auto x94 = V{0.666666666666667}*cell[11];
auto x95 = V{0.666666666666667}*cell[12];
auto x96 = V{0.666666666666667}*cell[13];
auto x97 = V{0.666666666666667}*cell[23];
auto x98 = V{0.666666666666667}*cell[24];
auto x99 = V{0.666666666666667}*cell[25];
auto x100 = V{0.666666666666667}*cell[26];
auto x101 = -V{0.333333333333333}*cell[0];
auto x102 = x100 + x101 + x93 + x94 + x95 + x96 + x97 + x98 + x99 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x103 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x104 = x102 + x103 - x27*x47*x48 - x37*x47*x47 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x105 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x106 = x102 + x105 - x28*x48*x70 - x37*x70*x70 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x107 = x100 + x101 + x103 + x105 - x29*x45*x48 - x37*x45*x45 + x93 + x94 + x95 + x96 + x97 + x98 + x99 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x108 = V{1} / (V{3.00000046417339}*util::sqrt(x37*(x32*x32)*util::sqrt(V{0.5}*(-x49*x71 - x51*x70 - x57 - x67 + x68 - x69 - x72 - x76)*(-x50*x82 - x71*x81 - x77 - x78 + x79 + x80 - x83 + V{2}*cell[17] - V{2}*cell[18] + V{2}*cell[4] - V{2}*cell[5]) + V{0.5}*(-x49*x86 - x55 - x60 - V{1}*x70*x87 - x72 - x84 + x85 - x88 - x92)*(x77 + x78 - x79 - x80 - x81*x86 - x82*x87 - x83 + V{2}*cell[21] - V{2}*cell[22] + V{2}*cell[8] - V{2}*cell[9]) + V{0.5}*(x104*x104) + V{0.5}*(x106*x106) + V{0.5}*(x107*x107) + x66*x66) + V{0.0277777691819762}/((x31)*(x31))) + V{0.5}/x31);
auto x109 = V{0.5}*x27;
auto x110 = V{1}*cell[1];
auto x111 = x54 + x58 + x68;
auto x112 = x39 + x40;
auto x113 = x110 + x111 + x112 - x38 + x52 + x65 - x67 + x76 + x88 - V{1}*cell[14];
auto x114 = -x113*x37;
auto x115 = x109 + x114;
auto x116 = V{0.5}*x28;
auto x117 = V{1}*cell[2];
auto x118 = x53 + x56 + x85;
auto x119 = x111 + x117 + x118 + x41 + x63 + x67 - x73 + x74 + x75 - x84 + x92 - V{1}*cell[15];
auto x120 = -x119*x37;
auto x121 = x116 + x120;
auto x122 = V{0.5}*x29;
auto x123 = V{1}*cell[3];
auto x124 = x112 + x118 + x123 + x38 + x54 + x59 - x61 + x62 + x64 + x69 + x84 - x89 + x90 + x91 - V{1}*cell[16];
auto x125 = -x124*x37;
auto x126 = x122 + x125;
auto x127 = V{-1} + V{1.5}*(x115*x115) + V{1.5}*(x121*x121) + V{1.5}*(x126*x126);
auto x128 = V{1} - x108;
auto x129 = V{0.0740740740740741}*cell[0] + V{0.0740740740740741}*cell[10] + V{0.0740740740740741}*cell[11] + V{0.0740740740740741}*cell[12] + V{0.0740740740740741}*cell[13] + V{0.0740740740740741}*cell[14] + V{0.0740740740740741}*cell[15] + V{0.0740740740740741}*cell[16] + V{0.0740740740740741}*cell[17] + V{0.0740740740740741}*cell[18] + V{0.0740740740740741}*cell[19] + V{0.0740740740740741}*cell[1] + V{0.0740740740740741}*cell[20] + V{0.0740740740740741}*cell[21] + V{0.0740740740740741}*cell[22] + V{0.0740740740740741}*cell[23] + V{0.0740740740740741}*cell[24] + V{0.0740740740740741}*cell[25] + V{0.0740740740740741}*cell[26] + V{0.0740740740740741}*cell[2] + V{0.0740740740740741}*cell[3] + V{0.0740740740740741}*cell[4] + V{0.0740740740740741}*cell[5] + V{0.0740740740740741}*cell[6] + V{0.0740740740740741}*cell[7] + V{0.0740740740740741}*cell[8] + V{0.0740740740740741}*cell[9] + V{0.0740740740740741};
auto x130 = V{2.25}*x27;
auto x131 = V{4.5}*cell[5];
auto x132 = V{4.5}*cell[7];
auto x133 = V{4.5}*cell[13];
auto x134 = V{4.5}*cell[18];
auto x135 = V{4.5}*cell[20];
auto x136 = V{4.5}*cell[26];
auto x137 = V{4.5}*cell[10];
auto x138 = V{4.5}*cell[11];
auto x139 = -V{4.5}*cell[23];
auto x140 = V{4.5}*cell[24];
auto x141 = x137 + x138 + x139 - x140 - V{4.5}*cell[17] + V{4.5}*cell[4];
auto x142 = V{4.5}*cell[12];
auto x143 = V{4.5}*cell[25];
auto x144 = x142 - x143 - V{4.5}*cell[19] + V{4.5}*cell[6];
auto x145 = x131 + x132 + x133 - x134 - x135 - x136 + x141 + x144 - V{4.5}*cell[14] + V{4.5}*cell[1];
auto x146 = -x145*x37;
auto x147 = x130 + x146;
auto x148 = V{1.5}*x27;
auto x149 = V{3}*cell[5];
auto x150 = V{3}*cell[7];
auto x151 = V{3}*cell[13];
auto x152 = V{3}*cell[18];
auto x153 = V{3}*cell[20];
auto x154 = V{3}*cell[26];
auto x155 = V{3}*cell[10];
auto x156 = V{3}*cell[11];
auto x157 = -V{3}*cell[23];
auto x158 = V{3}*cell[24];
auto x159 = x155 + x156 + x157 - x158 - V{3}*cell[17] + V{3}*cell[4];
auto x160 = V{3}*cell[12];
auto x161 = V{3}*cell[25];
auto x162 = x160 - x161 - V{3}*cell[19] + V{3}*cell[6];
auto x163 = x149 + x150 + x151 - x152 - x153 - x154 + x159 + x162 - V{3}*cell[14] + V{3}*cell[1];
auto x164 = -x163*x37;
auto x165 = x127 + x148 + x164;
auto x166 = V{2.25}*x28;
auto x167 = V{4.5}*cell[9];
auto x168 = V{4.5}*cell[22];
auto x169 = -x133 + x136 - V{4.5}*cell[21] + V{4.5}*cell[8];
auto x170 = -x131 + x134 + x141 - x142 + x143 + x167 - x168 + x169 - V{4.5}*cell[15] + V{4.5}*cell[2];
auto x171 = -x170*x37;
auto x172 = x166 + x171;
auto x173 = V{1.5}*x28;
auto x174 = V{3}*cell[9];
auto x175 = V{3}*cell[22];
auto x176 = -x151 + x154 - V{3}*cell[21] + V{3}*cell[8];
auto x177 = -x149 + x152 + x159 - x160 + x161 + x174 - x175 + x176 - V{3}*cell[15] + V{3}*cell[2];
auto x178 = -x177*x37;
auto x179 = x173 + x178;
auto x180 = x127 + x179;
auto x181 = V{2.25}*x29;
auto x182 = -x132 + x135 + x137 - x138 + x139 + x140 + x144 - x167 + x168 + x169 - V{4.5}*cell[16] + V{4.5}*cell[3];
auto x183 = -x182*x37;
auto x184 = x181 + x183;
auto x185 = V{1.5}*x29;
auto x186 = -x150 + x153 + x155 - x156 + x157 + x158 + x162 - x174 + x175 + x176 - V{3}*cell[16] + V{3}*cell[3];
auto x187 = -x186*x37;
auto x188 = x185 + x187;
auto x189 = x127 + x188;
auto x190 = V{0.0185185185185185}*cell[0] + V{0.0185185185185185}*cell[10] + V{0.0185185185185185}*cell[11] + V{0.0185185185185185}*cell[12] + V{0.0185185185185185}*cell[13] + V{0.0185185185185185}*cell[14] + V{0.0185185185185185}*cell[15] + V{0.0185185185185185}*cell[16] + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[1] + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[23] + V{0.0185185185185185}*cell[24] + V{0.0185185185185185}*cell[25] + V{0.0185185185185185}*cell[26] + V{0.0185185185185185}*cell[2] + V{0.0185185185185185}*cell[3] + V{0.0185185185185185}*cell[4] + V{0.0185185185185185}*cell[5] + V{0.0185185185185185}*cell[6] + V{0.0185185185185185}*cell[7] + V{0.0185185185185185}*cell[8] + V{0.0185185185185185}*cell[9] + V{0.0185185185185185};
auto x191 = x115 + x121;
auto x192 = x147 + x172;
auto x193 = x165 + x179;
auto x194 = -x116;
auto x195 = x115 - x120 + x194;
auto x196 = -x166;
auto x197 = x147 - x171 + x196;
auto x198 = -x173;
auto x199 = -x178 + x198;
auto x200 = x165 + x199;
auto x201 = -x122;
auto x202 = -x125 + x201;
auto x203 = x115 + x202;
auto x204 = -x181;
auto x205 = -x183 + x204;
auto x206 = x147 + x205;
auto x207 = -x185;
auto x208 = -x187 + x207;
auto x209 = x121 + x126;
auto x210 = x172 + x184;
auto x211 = x180 + x188;
auto x212 = x121 + x202;
auto x213 = x172 + x205;
auto x214 = V{0.00462962962962963}*cell[0] + V{0.00462962962962963}*cell[10] + V{0.00462962962962963}*cell[11] + V{0.00462962962962963}*cell[12] + V{0.00462962962962963}*cell[13] + V{0.00462962962962963}*cell[14] + V{0.00462962962962963}*cell[15] + V{0.00462962962962963}*cell[16] + V{0.00462962962962963}*cell[17] + V{0.00462962962962963}*cell[18] + V{0.00462962962962963}*cell[19] + V{0.00462962962962963}*cell[1] + V{0.00462962962962963}*cell[20] + V{0.00462962962962963}*cell[21] + V{0.00462962962962963}*cell[22] + V{0.00462962962962963}*cell[23] + V{0.00462962962962963}*cell[24] + V{0.00462962962962963}*cell[25] + V{0.00462962962962963}*cell[26] + V{0.00462962962962963}*cell[2] + V{0.00462962962962963}*cell[3] + V{0.00462962962962963}*cell[4] + V{0.00462962962962963}*cell[5] + V{0.00462962962962963}*cell[6] + V{0.00462962962962963}*cell[7] + V{0.00462962962962963}*cell[8] + V{0.00462962962962963}*cell[9] + V{0.00462962962962963};
auto x215 = x163*x37;
auto x216 = x109 - x113*x37;
auto x217 = x124*x37;
auto x218 = x201 + x217;
auto x219 = x119*x37;
auto x220 = x194 + x219;
auto x221 = x130 - x145*x37;
auto x222 = x182*x37;
auto x223 = x204 + x222;
auto x224 = x170*x37;
auto x225 = x196 + x224;
auto x226 = x216*x216;
auto x227 = x116 - x219;
auto x228 = x227*x227;
auto x229 = x122 - x217;
auto x230 = x229*x229;
auto x231 = V{1.5}*x226 + V{1.5}*x228 + V{1.5}*x230 + V{-1};
auto x232 = x177*x37;
auto x233 = x198 + x232;
auto x234 = x231 + x233;
auto x235 = x186*x37;
auto x236 = x207 + x235;
auto x237 = x234 + x236;
auto x238 = -x148;
auto x239 = x215 + x231 + x238;
auto x240 = x166 - x224;
auto x241 = x181 - x222;
auto x242 = x216 + x227;
auto x243 = x221 + x240;
auto x244 = x233 + x239;
auto x245 = -x164 + x238;
auto x246 = x216 + x229;
auto x247 = x221 + x241;
auto x248 = x236 + x239;
auto x0 = -x108*(x127*(V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296}) + V{0.296296296296296}) + V{1}*x128*cell[0];
auto x1 = -x108*(x129*(-x115*x147 + x165) + V{0.0740740740740741}) + x110*x128;
auto x2 = -x108*(x129*(-x121*x172 + x180) + V{0.0740740740740741}) + x117*x128;
auto x3 = -x108*(x129*(-x126*x184 + x189) + V{0.0740740740740741}) + x123*x128;
auto x4 = -x108*(x190*(-x191*x192 + x193) + V{0.0185185185185185}) + x128*x68;
auto x5 = -x108*(x190*(-x195*x197 + x200) + V{0.0185185185185185}) + x128*x73;
auto x6 = -x108*(x190*(x165 + x188 - (x115 + x126)*(x147 + x184)) + V{0.0185185185185185}) + x128*x39;
auto x7 = -x108*(x190*(x165 - x203*x206 + x208) + V{0.0185185185185185}) + x128*x61;
auto x8 = -x108*(x190*(-x209*x210 + x211) + V{0.0185185185185185}) + x128*x85;
auto x9 = -x108*(x190*(x180 + x208 - x212*x213) + V{0.0185185185185185}) + x128*x89;
auto x10 = -x108*(x214*(x188 + x193 - (x126 + x191)*(x184 + x192)) + V{0.00462962962962963}) + x128*x54;
auto x11 = -x108*(x214*(x193 + x208 - (-x191 - x202)*(-x192 - x205)) + V{0.00462962962962963}) + x128*x58;
auto x12 = -x108*(x214*(x188 + x200 - (-x126 - x195)*(-x184 - x197)) + V{0.00462962962962963}) + x128*x40;
auto x13 = -x108*(x214*(x148 - x215 + x237 - (-x216 - x218 - x220)*(-x221 - x223 - x225)) + V{0.00462962962962963}) + x128*x52;
auto x14 = -x108*(x129*(-x216*x221 + x239) + V{0.0740740740740741}) + V{1}*x128*cell[14];
auto x15 = -x108*(x129*(-x227*x240 + x234) + V{0.0740740740740741}) + V{1}*x128*cell[15];
auto x16 = -x108*(x129*(-x229*x241 + x231 + x236) + V{0.0740740740740741}) + V{1}*x128*cell[16];
auto x17 = -x108*(x190*(-x242*x243 + x244) + V{0.0185185185185185}) + V{1}*x128*cell[17];
auto x18 = -x108*(x190*(x180 - x195*x197 + x245) + V{0.0185185185185185}) + x128*x67;
auto x19 = -x108*(x190*(-x246*x247 + x248) + V{0.0185185185185185}) + V{1}*x128*cell[19];
auto x20 = -x108*(x190*(x189 - x203*x206 + x245) + V{0.0185185185185185}) + x128*x38;
auto x21 = -x108*(x190*(x237 - (x227 + x229)*(x240 + x241)) + V{0.0185185185185185}) + V{1}*x128*cell[21];
auto x22 = -x108*(x190*(x189 + x199 - x212*x213) + V{0.0185185185185185}) + x128*x84;
auto x23 = -x108*(x214*(x236 + x244 - (x229 + x242)*(x241 + x243)) + V{0.00462962962962963}) + V{1}*x128*cell[23];
auto x24 = -x108*(x214*(x185 - x235 + x244 - (x218 + x242)*(x223 + x243)) + V{0.00462962962962963}) + x128*x59;
auto x25 = -x108*(x214*(x173 - x232 + x248 - (x220 + x246)*(x225 + x247)) + V{0.00462962962962963}) + x128*x63;
auto x26 = -x108*(x214*(x211 + x245 - (x109 + x114 - x209)*(x130 + x146 - x210)) + V{0.00462962962962963}) + x128*x53;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { x36, x226 + x228 + x230 };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x27 = cell.template getFieldComponent<olb::descriptors::FORCE>(0);
auto x28 = cell.template getFieldComponent<olb::descriptors::FORCE>(1);
auto x29 = cell.template getFieldComponent<olb::descriptors::FORCE>(2);
auto x32 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = cell[20] + cell[22] + cell[24] + cell[3];
auto x1 = cell[13] + cell[1] + cell[5] + cell[7];
auto x2 = cell[10] + cell[18] + cell[25] + cell[2] + cell[9];
auto x3 = x0 + x1 + x2 + cell[0] + cell[11] + cell[12] + cell[14] + cell[15] + cell[16] + cell[17] + cell[19] + cell[21] + cell[23] + cell[26] + cell[4] + cell[6] + cell[8];
auto x4 = V{1} / (x3 + V{1});
auto x5 = V{1}*cell[12];
auto x6 = V{1}*cell[25];
auto x7 = -cell[23];
auto x8 = x7 + cell[10] + cell[12] - cell[19] - cell[25] + cell[6];
auto x9 = -cell[13] - cell[21] + cell[26] + cell[8];
auto x10 = x0 + x8 + x9 - cell[11] - cell[16] - cell[7] - cell[9];
auto x11 = cell[11] - cell[17] - cell[24] + cell[4];
auto x12 = x1 + x11 + x8 - cell[14] - cell[18] - cell[20] - cell[26];
auto x13 = x4*(x3 + V{1});
auto x14 = V{0.5}*x13;
auto x15 = x12*x4;
auto x16 = V{1}*x15;
auto x17 = V{1}*cell[13];
auto x18 = V{1}*cell[26];
auto x19 = -V{1}*cell[10];
auto x20 = -V{1}*cell[23];
auto x21 = x17 + x18 + x19 + x20;
auto x22 = V{1}*cell[11];
auto x23 = V{1}*cell[24];
auto x24 = x22 + x23;
auto x25 = -x10*x16 - x14*(x10*x27 + x12*x29) - x21 - x24 + x5 + x6 + V{1}*cell[19] - V{1}*cell[20] + V{1}*cell[6] - V{1}*cell[7];
auto x26 = x11 + x2 + x7 + x9 - cell[12] - cell[15] - cell[22] - cell[5];
auto x30 = x12*x28 + x26*x27;
auto x33 = x5 + x6;
auto x34 = V{2}*cell[13];
auto x35 = V{2}*cell[26];
auto x36 = V{2}*cell[11];
auto x37 = V{2}*cell[24];
auto x38 = V{1}*x13;
auto x39 = V{2}*x26;
auto x40 = -V{2}*cell[10] + V{2}*cell[12] - V{2}*cell[23] + V{2}*cell[25];
auto x41 = x10*x28 + x26*x29;
auto x42 = x10*x4;
auto x43 = V{0.666666666666667}*cell[10];
auto x44 = V{0.666666666666667}*cell[11];
auto x45 = V{0.666666666666667}*cell[12];
auto x46 = V{0.666666666666667}*cell[13];
auto x47 = V{0.666666666666667}*cell[23];
auto x48 = V{0.666666666666667}*cell[24];
auto x49 = V{0.666666666666667}*cell[25];
auto x50 = V{0.666666666666667}*cell[26];
auto x51 = -V{0.333333333333333}*cell[0];
auto x52 = x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x53 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x54 = -x12*x13*x27 - x4*x12*x12 + x52 + x53 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x55 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x56 = -x13*x26*x28 - x4*x26*x26 + x52 + x55 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x57 = -x10*x13*x29 - x4*x10*x10 + x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x53 + x55 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
return V{1} / (V{2.52268963608289}*util::sqrt(x4*(x32*x32)*util::sqrt((-x14*x30 - x16*x26 - x21 + x22 + x23 - x33 + V{1}*cell[17] - V{1}*cell[18] + V{1}*cell[4] - V{1}*cell[5])*(-x15*x39 - x30*x38 - x34 - x35 + x36 + x37 - x40 + V{2}*cell[17] - V{2}*cell[18] + V{2}*cell[4] - V{2}*cell[5]) + (x34 + x35 - x36 - x37 - x38*x41 - x39*x42 - x40 + V{2}*cell[21] - V{2}*cell[22] + V{2}*cell[8] - V{2}*cell[9])*(-x14*x41 + x17 + x18 - x19 - x20 - x24 - V{1}*x26*x42 - x33 + V{1}*cell[21] - V{1}*cell[22] + V{1}*cell[8] - V{1}*cell[9]) + 2*(x25*x25) + x54*x54 + x56*x56 + x57*x57) + V{0.0392836979096202}/((x31)*(x31))) + V{0.5}/x31);
}
 
};
 
 
template <typename... FIELDS>
struct ShearSmagorinskyEffectiveOmega<BGK,descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::descriptors::LATTICE_TIME>();
auto x14 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x11 = cell.template getFieldComponent<olb::descriptors::AV_SHEAR>(0);
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x9 = cell[1] + cell[7];
auto x10 = x9 + cell[0] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + V{1};
auto x15 = V{1} / (x10);
auto x16 = V{1}*x15;
auto x17 = -cell[5];
auto x18 = x17 + cell[3];
auto x19 = cell[2] - cell[6];
auto x20 = x18 + x19 + cell[1] - cell[7];
auto x21 = x20*x20;
auto x22 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x23 = -x16*x21 + x22 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x24 = -cell[4] + cell[8];
auto x25 = x17 + x24 + x9 - cell[3];
auto x26 = x25*x25;
auto x27 = -x16*x26 + x22 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x28 = -x15*x20*x25 - x18 + cell[1] - cell[7];
auto x29 = V{1.4142135623731}*util::sqrt(V{0.5}*(x23*x23) + V{0.5}*(x27*x27) + x28*x28);
auto x30 = (x11*x13 + x29)/(x13 + V{1});
auto x31 = V{1} / (V{2.52268963608289}*util::sqrt(x15*(x29 - x30)*(x14*x14) + V{0.0392836979096202}/((x12)*(x12))) + V{0.5}/x12);
auto x32 = V{1} / ((x10)*(x10));
auto x33 = V{1.5}*x32;
auto x34 = x26*x33;
auto x35 = -x20;
auto x36 = x33*(x35*x35) + V{-1};
auto x37 = x34 + x36;
auto x38 = V{1} - x31;
auto x39 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778};
auto x40 = V{4.5}*x32;
auto x41 = x19 + x24 + V{2}*cell[1] - V{2}*cell[5];
auto x42 = x40*(x41*x41);
auto x43 = V{3}*cell[3];
auto x44 = V{3}*cell[7];
auto x45 = V{3}*cell[1] - V{3}*cell[5];
auto x46 = x43 - x44 + x45 + V{3}*cell[2] - V{3}*cell[6];
auto x47 = x15*x46;
auto x48 = -x34 + x47 + V{1};
auto x49 = -x43 + x44 + x45 - V{3}*cell[4] + V{3}*cell[8];
auto x50 = x15*x49;
auto x51 = x21*x33;
auto x52 = x50 - x51;
auto x53 = V{0.111111111111111}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7] + V{0.111111111111111}*cell[8] + V{0.111111111111111};
auto x54 = V{3}*x32;
auto x55 = x19 + V{2}*cell[3] + cell[4] - V{2}*cell[7] - cell[8];
auto x56 = -x55;
auto x57 = x26*x54;
auto x58 = x34 + x47 + V{-1};
auto x59 = x51 + x58;
auto x0 = -x31*(x37*(V{0.444444444444444}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}) + V{0.444444444444444}) + V{1}*x38*cell[0];
auto x1 = x31*(x39*(x42 + x48 + x52) + V{-0.0277777777777778}) + V{1}*x38*cell[1];
auto x2 = x31*(x53*(x21*x54 + x48) + V{-0.111111111111111}) + V{1}*x38*cell[2];
auto x3 = -x31*(x39*(-x15*x46 + x37 - x40*x56*x56 + x50) + V{0.0277777777777778}) + V{1}*x38*cell[3];
auto x4 = -x31*(x53*(x36 + x50 - x57) + V{0.111111111111111}) + V{1}*x38*cell[4];
auto x5 = -x31*(x39*(-x42 + x50 + x59) + V{0.0277777777777778}) + V{1}*x38*cell[5];
auto x6 = x31*(x53*(V{3}*x21*x32 - x58) + V{-0.111111111111111}) + V{1}*x38*cell[6];
auto x7 = x31*(-x39*(-x15*x49 - V{4.5}*x32*x55*x55 + x59) + V{-0.0277777777777778}) + V{1}*x38*cell[7];
auto x8 = x31*(x53*(x52 + x57 + V{1}) + V{-0.111111111111111}) + V{1}*x38*cell[8];
cell.template getFieldPointer<olb::descriptors::AV_SHEAR>()[0] = x30;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { x10, V{1}*x32*(x21 + x26) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::descriptors::LATTICE_TIME>();
auto x14 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x11 = cell.template getFieldComponent<olb::descriptors::AV_SHEAR>(0);
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = cell[1] + cell[2];
auto x1 = cell[7] + cell[8];
auto x2 = V{1} / (x0 + x1 + cell[0] + cell[3] + cell[4] + cell[5] + cell[6] + V{1});
auto x3 = V{1}*x2;
auto x4 = -cell[5];
auto x5 = x4 + cell[3];
auto x6 = x0 + x5 - cell[6] - cell[7];
auto x7 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x8 = -x3*x6*x6 + x7 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x9 = x1 + x4 + cell[1] - cell[3] - cell[4];
auto x10 = -x3*x9*x9 + x7 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x15 = -x2*x6*x9 - x5 + cell[1] - cell[7];
auto x16 = V{1.4142135623731}*util::sqrt(V{0.5}*(x10*x10) + x15*x15 + V{0.5}*(x8*x8));
return V{1} / (V{2.52268963608289}*util::sqrt(x2*(x16 - (x11*x13 + x16)/(x13 + V{1}))*(x14*x14) + V{0.0392836979096202}/((x12)*(x12))) + V{0.5}/x12);
}
 
};
 
template <typename... FIELDS>
struct ShearSmagorinskyEffectiveOmega<BGK,descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x22 = cell.template getFieldComponent<olb::descriptors::AV_SHEAR>(0);
auto x25 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x24 = parameters.template get<olb::descriptors::LATTICE_TIME>();
auto x19 = cell[15] + cell[17];
auto x20 = x19 + cell[12];
auto x21 = cell[11] + cell[18];
auto x26 = cell[10] + cell[14] + cell[16];
auto x27 = cell[2] + cell[8] + cell[9];
auto x28 = cell[13] + cell[3];
auto x29 = x20 + x21 + x26 + x27 + x28 + cell[0] + cell[1] + cell[4] + cell[5] + cell[6] + cell[7] + V{1};
auto x30 = V{1} / (x29);
auto x31 = V{0.333333333333333}*cell[4];
auto x32 = V{0.333333333333333}*cell[5];
auto x33 = V{0.333333333333333}*cell[13];
auto x34 = V{0.333333333333333}*cell[14];
auto x35 = V{1}*x30;
auto x36 = -cell[3];
auto x37 = -cell[18];
auto x38 = -cell[8];
auto x39 = x38 + cell[9];
auto x40 = x36 + x37 + x39;
auto x41 = -cell[6];
auto x42 = x41 + cell[7];
auto x43 = x42 - cell[16];
auto x44 = x20 + x40 + x43;
auto x45 = x44*x44;
auto x46 = V{0.333333333333333}*cell[0];
auto x47 = V{0.333333333333333}*cell[1];
auto x48 = V{0.333333333333333}*cell[10];
auto x49 = x46 + x47 + x48 - V{0.666666666666667}*cell[17] - V{0.666666666666667}*cell[18] - V{0.666666666666667}*cell[8] - V{0.666666666666667}*cell[9];
auto x50 = V{0.333333333333333}*cell[2];
auto x51 = V{0.333333333333333}*cell[11];
auto x52 = x50 + x51 - V{0.666666666666667}*cell[15] - V{0.666666666666667}*cell[16] - V{0.666666666666667}*cell[6] - V{0.666666666666667}*cell[7];
auto x53 = x31 + x32 + x33 + x34 + x35*x45 + x49 + x52 - V{0.666666666666667}*cell[12] - V{0.666666666666667}*cell[3];
auto x54 = V{0.333333333333333}*cell[6];
auto x55 = V{0.333333333333333}*cell[7];
auto x56 = V{0.333333333333333}*cell[15];
auto x57 = V{0.333333333333333}*cell[16];
auto x58 = cell[13] + cell[17];
auto x59 = -cell[2];
auto x60 = -cell[9];
auto x61 = x21 + x38 + x59 + x60;
auto x62 = -cell[4];
auto x63 = x62 + cell[5];
auto x64 = x63 - cell[14];
auto x65 = x58 + x61 + x64;
auto x66 = x65*x65;
auto x67 = V{0.333333333333333}*cell[3];
auto x68 = V{0.333333333333333}*cell[12];
auto x69 = x67 + x68 - V{0.666666666666667}*cell[13] - V{0.666666666666667}*cell[14] - V{0.666666666666667}*cell[4] - V{0.666666666666667}*cell[5];
auto x70 = x35*x66 + x49 + x54 + x55 + x56 + x57 + x69 - V{0.666666666666667}*cell[11] - V{0.666666666666667}*cell[2];
auto x71 = V{0.333333333333333}*cell[8];
auto x72 = V{0.333333333333333}*cell[9];
auto x73 = V{0.333333333333333}*cell[17];
auto x74 = V{0.333333333333333}*cell[18];
auto x75 = cell[13] + cell[15];
auto x76 = -cell[1];
auto x77 = -cell[7];
auto x78 = x41 + x76 + x77;
auto x79 = x62 - cell[5];
auto x80 = x26 + x75 + x78 + x79;
auto x81 = x80*x80;
auto x82 = x35*x81 + x46 + x52 + x69 + x71 + x72 + x73 + x74 - V{0.666666666666667}*cell[10] - V{0.666666666666667}*cell[1];
auto x83 = x30*x80;
auto x84 = x63 + x65*x83 - cell[13] + cell[14];
auto x85 = -cell[15] + cell[16];
auto x86 = x42 + x44*x83 + x85;
auto x87 = -cell[17];
auto x88 = x87 + cell[18];
auto x89 = x30*x44*x65 + x39 + x88;
auto x90 = V{1.4142135623731}*util::sqrt(V{0.5}*(x53*x53) + V{0.5}*(x70*x70) + V{0.5}*(x82*x82) + x84*x84 + x86*x86 + x89*x89);
auto x91 = (x22*x24 + x90)/(x24 + V{1});
auto x92 = V{1} / (V{2.52268963608289}*util::sqrt(x30*(x90 - x91)*(x25*x25) + V{0.0392836979096202}/((x23)*(x23))) + V{0.5}/x23);
auto x93 = V{1} / ((x29)*(x29));
auto x94 = V{1.5}*x93;
auto x95 = x81*x94;
auto x96 = x66*x94;
auto x97 = x45*x94;
auto x98 = x96 + x97 + V{-1};
auto x99 = x95 + x98;
auto x100 = V{1} - x92;
auto x101 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[10] + V{0.0555555555555556}*cell[11] + V{0.0555555555555556}*cell[12] + V{0.0555555555555556}*cell[13] + V{0.0555555555555556}*cell[14] + V{0.0555555555555556}*cell[15] + V{0.0555555555555556}*cell[16] + V{0.0555555555555556}*cell[17] + V{0.0555555555555556}*cell[18] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556}*cell[9] + V{0.0555555555555556};
auto x102 = V{3}*cell[14];
auto x103 = V{3}*cell[16];
auto x104 = V{3}*cell[5];
auto x105 = V{3}*cell[7];
auto x106 = V{3}*cell[13] - V{3}*cell[4];
auto x107 = V{3}*cell[15] - V{3}*cell[6];
auto x108 = x30*(x102 + x103 - x104 - x105 + x106 + x107 + V{3}*cell[10] - V{3}*cell[1]);
auto x109 = V{3}*x93;
auto x110 = x109*x81;
auto x111 = V{3}*cell[18];
auto x112 = V{3}*cell[9];
auto x113 = V{3}*cell[17] - V{3}*cell[8];
auto x114 = x30*(-x102 + x104 + x106 + x111 - x112 + x113 + V{3}*cell[11] - V{3}*cell[2]);
auto x115 = x109*x66;
auto x116 = x95 + V{-1};
auto x117 = x30*(-x103 + x105 + x107 - x111 + x112 + x113 + V{3}*cell[12] - V{3}*cell[3]);
auto x118 = x109*x45;
auto x119 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x120 = V{4.5}*x93;
auto x121 = x78 + cell[10] + cell[16];
auto x122 = x121 + x19 + x61 + V{2}*cell[13] - V{2}*cell[4];
auto x123 = x120*(x122*x122);
auto x124 = x108 + x99;
auto x125 = -x114;
auto x126 = x121 + x27 + x37 + x87 - cell[11] + V{2}*cell[14] + cell[15] - V{2}*cell[5];
auto x127 = -x126;
auto x128 = x76 + x79 + cell[10] + cell[14];
auto x129 = x128 + x40 + x58 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x130 = x120*(x129*x129);
auto x131 = -x117;
auto x132 = x28 - cell[12];
auto x133 = x128 + x132 + x60 + x88 + V{2}*cell[16] - V{2}*cell[7] + cell[8];
auto x134 = -x133;
auto x135 = x59 + x64 + cell[11];
auto x136 = x135 + x36 + x43 + x75 + cell[12] + V{2}*cell[17] - V{2}*cell[8];
auto x137 = x120*(x136*x136);
auto x138 = x114 + x99;
auto x139 = x132 + x135 + x77 + x85 + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x140 = -x139;
auto x141 = -x96;
auto x142 = V{1} - x97;
auto x143 = x141 + x142;
auto x144 = x108 + x143;
auto x145 = -x95;
auto x146 = x114 + x145;
auto x147 = x117 + x145;
auto x148 = -x108;
auto x149 = x117 + x99;
cell[0] = V{1}*x100*cell[0] - x92*(x99*(x31 + x32 + x33 + x34 + x46 + x47 + x48 + x50 + x51 + x54 + x55 + x56 + x57 + x67 + x68 + x71 + x72 + x73 + x74 + V{0.333333333333333}) + V{0.333333333333333});
cell[1] = V{1}*x100*cell[1] - x92*(x101*(x108 - x110 + x98) + V{0.0555555555555556});
cell[2] = V{1}*x100*cell[2] - x92*(x101*(x114 - x115 + x116 + x97) + V{0.0555555555555556});
cell[3] = V{1}*x100*cell[3] - x92*(x101*(x116 + x117 - x118 + x96) + V{0.0555555555555556});
cell[4] = V{1}*x100*cell[4] - x92*(x119*(x114 - x123 + x124) + V{0.0277777777777778});
cell[5] = V{1}*x100*cell[5] - x92*(x119*(-x120*x127*x127 + x124 + x125) + V{0.0277777777777778});
cell[6] = V{1}*x100*cell[6] - x92*(x119*(x117 + x124 - x130) + V{0.0277777777777778});
cell[7] = V{1}*x100*cell[7] - x92*(x119*(-x120*x134*x134 + x124 + x131) + V{0.0277777777777778});
cell[8] = V{1}*x100*cell[8] - x92*(x119*(x117 - x137 + x138) + V{0.0277777777777778});
cell[9] = V{1}*x100*cell[9] - x92*(x119*(-x120*x140*x140 + x131 + x138) + V{0.0277777777777778});
cell[10] = V{1}*x100*cell[10] + x92*(x101*(x110 + x144) + V{-0.0555555555555556});
cell[11] = V{1}*x100*cell[11] + x92*(x101*(x115 + x142 + x146) + V{-0.0555555555555556});
cell[12] = V{1}*x100*cell[12] + x92*(x101*(x118 + x141 + x147 + V{1}) + V{-0.0555555555555556});
cell[13] = V{1}*x100*cell[13] + x92*(x119*(x123 + x144 + x146) + V{-0.0277777777777778});
cell[14] = V{1}*x100*cell[14] - x92*(x119*(-x120*x126*x126 + x138 + x148) + V{0.0277777777777778});
cell[15] = V{1}*x100*cell[15] + x92*(x119*(x130 + x144 + x147) + V{-0.0277777777777778});
cell[16] = V{1}*x100*cell[16] - x92*(x119*(-x120*x133*x133 + x148 + x149) + V{0.0277777777777778});
cell[17] = V{1}*x100*cell[17] + x92*(x119*(x117 + x137 + x143 + x146) + V{-0.0277777777777778});
cell[18] = V{1}*x100*cell[18] - x92*(x119*(-x120*x139*x139 + x125 + x149) + V{0.0277777777777778});
cell.template getFieldPointer<olb::descriptors::AV_SHEAR>()[0] = x91;
return { x29, V{1}*x93*(x45 + x66 + x81) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x24 = parameters.template get<olb::descriptors::LATTICE_TIME>();
auto x22 = cell.template getFieldComponent<olb::descriptors::AV_SHEAR>(0);
auto x25 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x0 = cell[12] + cell[15] + cell[17];
auto x1 = cell[11] + cell[13] + cell[18];
auto x2 = cell[10] + cell[14] + cell[16];
auto x3 = V{1} / (x0 + x1 + x2 + cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1});
auto x4 = V{1}*x3;
auto x5 = -cell[6];
auto x6 = x5 + cell[7];
auto x7 = -cell[8];
auto x8 = x7 + cell[9];
auto x9 = x0 + x6 + x8 - cell[16] - cell[18] - cell[3];
auto x10 = V{0.333333333333333}*cell[0];
auto x11 = x10 + V{0.333333333333333}*cell[10] - V{0.666666666666667}*cell[17] - V{0.666666666666667}*cell[18] + V{0.333333333333333}*cell[1] - V{0.666666666666667}*cell[8] - V{0.666666666666667}*cell[9];
auto x12 = V{0.333333333333333}*cell[11] - V{0.666666666666667}*cell[15] - V{0.666666666666667}*cell[16] + V{0.333333333333333}*cell[2] - V{0.666666666666667}*cell[6] - V{0.666666666666667}*cell[7];
auto x13 = x11 + x12 + x4*(x9*x9) - V{0.666666666666667}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] - V{0.666666666666667}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5];
auto x14 = -cell[4];
auto x15 = x14 + cell[5];
auto x16 = x1 + x15 + x7 - cell[14] + cell[17] - cell[2] - cell[9];
auto x17 = V{0.333333333333333}*cell[12] - V{0.666666666666667}*cell[13] - V{0.666666666666667}*cell[14] + V{0.333333333333333}*cell[3] - V{0.666666666666667}*cell[4] - V{0.666666666666667}*cell[5];
auto x18 = x11 + x17 + x4*(x16*x16) - V{0.666666666666667}*cell[11] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] - V{0.666666666666667}*cell[2] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7];
auto x19 = x14 + x2 + x5 + cell[13] + cell[15] - cell[1] - cell[5] - cell[7];
auto x20 = x10 + x12 + x17 + x4*(x19*x19) - V{0.666666666666667}*cell[10] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] - V{0.666666666666667}*cell[1] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9];
auto x21 = x19*x3;
auto x26 = x15 + x16*x21 - cell[13] + cell[14];
auto x27 = x21*x9 + x6 - cell[15] + cell[16];
auto x28 = x16*x3*x9 + x8 - cell[17] + cell[18];
auto x29 = V{1.4142135623731}*util::sqrt(V{0.5}*(x13*x13) + V{0.5}*(x18*x18) + V{0.5}*(x20*x20) + x26*x26 + x27*x27 + x28*x28);
return V{1} / (V{2.52268963608289}*util::sqrt(x3*(x29 - (x22*x24 + x29)/(x24 + V{1}))*(x25*x25) + V{0.0392836979096202}/((x23)*(x23))) + V{0.5}/x23);
}
 
};
 
template <typename... FIELDS>
struct ShearSmagorinskyEffectiveOmega<BGK,descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x33 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x32 = parameters.template get<olb::descriptors::LATTICE_TIME>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x30 = cell.template getFieldComponent<olb::descriptors::AV_SHEAR>(0);
auto x27 = cell[10] + cell[6];
auto x28 = x27 + cell[13];
auto x29 = cell[12] + cell[26];
auto x34 = cell[15] + cell[21];
auto x35 = cell[19] + cell[7];
auto x36 = cell[24] + cell[25];
auto x37 = x36 + cell[14];
auto x38 = x28 + x29 + x34 + x35 + x37 + cell[0] + cell[11] + cell[16] + cell[17] + cell[18] + cell[1] + cell[20] + cell[22] + cell[23] + cell[2] + cell[3] + cell[4] + cell[5] + cell[8] + cell[9] + V{1};
auto x39 = V{1} / (x38);
auto x40 = V{1}*x39;
auto x41 = -cell[24];
auto x42 = -cell[19];
auto x43 = x42 + cell[7];
auto x44 = -cell[25];
auto x45 = x44 + cell[11];
auto x46 = x43 + x45;
auto x47 = -cell[23];
auto x48 = -cell[26];
auto x49 = x47 + x48 + cell[12];
auto x50 = -cell[20];
auto x51 = x50 + cell[4];
auto x52 = -cell[17];
auto x53 = x52 + cell[5];
auto x54 = -cell[14] + cell[1];
auto x55 = x53 + x54 - cell[18];
auto x56 = x28 + x41 + x46 + x49 + x51 + x55;
auto x57 = x56*x56;
auto x58 = V{0.666666666666667}*cell[10];
auto x59 = V{0.666666666666667}*cell[11];
auto x60 = V{0.666666666666667}*cell[12];
auto x61 = V{0.666666666666667}*cell[13];
auto x62 = V{0.666666666666667}*cell[23];
auto x63 = V{0.666666666666667}*cell[24];
auto x64 = V{0.666666666666667}*cell[25];
auto x65 = V{0.666666666666667}*cell[26];
auto x66 = -V{0.333333333333333}*cell[0];
auto x67 = x58 + x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x68 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x69 = -x40*x57 + x67 + x68 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x70 = -cell[12];
auto x71 = x70 + cell[26];
auto x72 = -cell[13];
auto x73 = -cell[21];
auto x74 = x73 + cell[9];
auto x75 = x72 + x74 + cell[11];
auto x76 = x47 + cell[8];
auto x77 = -cell[22];
auto x78 = x77 + cell[4];
auto x79 = -cell[15] + cell[2];
auto x80 = x79 + cell[10];
auto x81 = x52 + cell[18] - cell[5];
auto x82 = x41 + x71 + x75 + x76 + x78 + x80 + x81 + cell[25];
auto x83 = x82*x82;
auto x84 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x85 = -x40*x83 + x67 + x84 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x86 = -cell[11];
auto x87 = -cell[16];
auto x88 = x72 + x87 + cell[3];
auto x89 = -cell[9];
auto x90 = x73 + x89 + cell[22];
auto x91 = x42 + cell[20] - cell[7];
auto x92 = x27 + x29 + x44 + x76 + x86 + x88 + x90 + x91 + cell[24];
auto x93 = x92*x92;
auto x94 = -x40*x93 + x58 + x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 + x68 + x84 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x95 = -cell[10];
auto x96 = x39*x56;
auto x97 = x41 + cell[12] + cell[26];
auto x98 = x47 + cell[13] + cell[25];
auto x99 = x53 + x82*x96 + x86 + x95 + x97 + x98 + cell[18] - cell[4];
auto x100 = -cell[6];
auto x101 = x47 + cell[13] + cell[24];
auto x102 = x100 + x101 + x46 + x71 + x92*x96 + x95 + cell[20];
auto x103 = -cell[8];
auto x104 = x103 + cell[22];
auto x105 = x104 + x36 + x39*x82*x92 + x49 + x75 + x95;
auto x106 = V{1.4142135623731}*util::sqrt(x102*x102 + x105*x105 + V{0.5}*(x69*x69) + V{0.5}*(x85*x85) + V{0.5}*(x94*x94) + x99*x99);
auto x107 = (x106 + x30*x32)/(x32 + V{1});
auto x108 = V{1} / (V{2.52268963608289}*util::sqrt(x39*(x106 - x107)*(x33*x33) + V{0.0392836979096202}/((x31)*(x31))) + V{0.5}/x31);
auto x109 = V{1} / ((x38)*(x38));
auto x110 = V{1.5}*x109;
auto x111 = -x56;
auto x112 = x111*x111;
auto x113 = x110*x112;
auto x114 = -x82;
auto x115 = x114*x114;
auto x116 = x110*x115;
auto x117 = -x92;
auto x118 = x117*x117;
auto x119 = x110*x118;
auto x120 = x116 + x119 + V{-1};
auto x121 = x113 + x120;
auto x122 = V{1} - x108;
auto x123 = V{0.0740740740740741}*cell[0] + V{0.0740740740740741}*cell[10] + V{0.0740740740740741}*cell[11] + V{0.0740740740740741}*cell[12] + V{0.0740740740740741}*cell[13] + V{0.0740740740740741}*cell[14] + V{0.0740740740740741}*cell[15] + V{0.0740740740740741}*cell[16] + V{0.0740740740740741}*cell[17] + V{0.0740740740740741}*cell[18] + V{0.0740740740740741}*cell[19] + V{0.0740740740740741}*cell[1] + V{0.0740740740740741}*cell[20] + V{0.0740740740740741}*cell[21] + V{0.0740740740740741}*cell[22] + V{0.0740740740740741}*cell[23] + V{0.0740740740740741}*cell[24] + V{0.0740740740740741}*cell[25] + V{0.0740740740740741}*cell[26] + V{0.0740740740740741}*cell[2] + V{0.0740740740740741}*cell[3] + V{0.0740740740740741}*cell[4] + V{0.0740740740740741}*cell[5] + V{0.0740740740740741}*cell[6] + V{0.0740740740740741}*cell[7] + V{0.0740740740740741}*cell[8] + V{0.0740740740740741}*cell[9] + V{0.0740740740740741};
auto x124 = V{3}*cell[5];
auto x125 = V{3}*cell[7];
auto x126 = V{3}*cell[13];
auto x127 = V{3}*cell[18];
auto x128 = V{3}*cell[20];
auto x129 = V{3}*cell[26];
auto x130 = V{3}*cell[10];
auto x131 = V{3}*cell[11];
auto x132 = -V{3}*cell[23];
auto x133 = V{3}*cell[24];
auto x134 = x130 + x131 + x132 - x133 - V{3}*cell[17] + V{3}*cell[4];
auto x135 = V{3}*cell[12];
auto x136 = V{3}*cell[25];
auto x137 = x135 - x136 - V{3}*cell[19] + V{3}*cell[6];
auto x138 = x124 + x125 + x126 - x127 - x128 - x129 + x134 + x137 - V{3}*cell[14] + V{3}*cell[1];
auto x139 = -x138*x39;
auto x140 = V{3}*x109;
auto x141 = V{3}*cell[9];
auto x142 = V{3}*cell[22];
auto x143 = -x126 + x129 - V{3}*cell[21] + V{3}*cell[8];
auto x144 = -x124 + x127 + x134 - x135 + x136 + x141 - x142 + x143 - V{3}*cell[15] + V{3}*cell[2];
auto x145 = -x144*x39;
auto x146 = x113 + V{-1};
auto x147 = -x125 + x128 + x130 - x131 + x132 + x133 + x137 - x141 + x142 + x143 - V{3}*cell[16] + V{3}*cell[3];
auto x148 = -x147*x39;
auto x149 = V{0.0185185185185185}*cell[0] + V{0.0185185185185185}*cell[10] + V{0.0185185185185185}*cell[11] + V{0.0185185185185185}*cell[12] + V{0.0185185185185185}*cell[13] + V{0.0185185185185185}*cell[14] + V{0.0185185185185185}*cell[15] + V{0.0185185185185185}*cell[16] + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[1] + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[23] + V{0.0185185185185185}*cell[24] + V{0.0185185185185185}*cell[25] + V{0.0185185185185185}*cell[26] + V{0.0185185185185185}*cell[2] + V{0.0185185185185185}*cell[3] + V{0.0185185185185185}*cell[4] + V{0.0185185185185185}*cell[5] + V{0.0185185185185185}*cell[6] + V{0.0185185185185185}*cell[7] + V{0.0185185185185185}*cell[8] + V{0.0185185185185185}*cell[9] + V{0.0185185185185185};
auto x150 = V{4.5}*x109;
auto x151 = -V{2}*cell[23];
auto x152 = V{2}*cell[10];
auto x153 = x151 + x152 + cell[8];
auto x154 = V{2}*cell[11] - V{2}*cell[24];
auto x155 = x154 + x79;
auto x156 = x54 - V{2}*cell[17] + V{2}*cell[4];
auto x157 = x43 + x50 + cell[6];
auto x158 = x153 + x155 + x156 + x157 + x74 + x77;
auto x159 = -x158;
auto x160 = x121 + x139;
auto x161 = x145 + x160;
auto x162 = V{2}*cell[25];
auto x163 = V{2}*cell[12];
auto x164 = -x162 + x163;
auto x165 = V{2}*cell[26];
auto x166 = V{2}*cell[13];
auto x167 = -x165 + x166;
auto x168 = V{2}*cell[18];
auto x169 = V{2}*cell[5];
auto x170 = -x168 + x169 + x54 - cell[2];
auto x171 = x104 + x157 + x164 + x167 + x170 + x34 + x89;
auto x172 = -x145;
auto x173 = x160 + x172;
auto x174 = -V{2}*cell[19] + V{2}*cell[6];
auto x175 = x87 + cell[3];
auto x176 = x175 + cell[4];
auto x177 = x153 + x164 + x174 + x176 + x55 + x90;
auto x178 = -x177;
auto x179 = -x148;
auto x180 = V{2}*cell[20];
auto x181 = V{2}*cell[7];
auto x182 = cell[16] - cell[3];
auto x183 = -x180 + x181 + x182;
auto x184 = x103 + x154 + x167 + x183 + x55 + x78 + cell[21] + cell[9];
auto x185 = -V{2}*cell[21] + V{2}*cell[8];
auto x186 = x185 + x79;
auto x187 = x151 + x152 + x165 - x166 + x176 + x186 + x81 + x91 + cell[6];
auto x188 = -x187;
auto x189 = x121 + x145;
auto x190 = x148 + x189;
auto x191 = V{2}*cell[22];
auto x192 = V{2}*cell[9];
auto x193 = -x191 + x192;
auto x194 = x100 + x155 + x162 - x163 + x182 + x193 + x35 + x51 + x81;
auto x195 = V{0.00462962962962963}*cell[0] + V{0.00462962962962963}*cell[10] + V{0.00462962962962963}*cell[11] + V{0.00462962962962963}*cell[12] + V{0.00462962962962963}*cell[13] + V{0.00462962962962963}*cell[14] + V{0.00462962962962963}*cell[15] + V{0.00462962962962963}*cell[16] + V{0.00462962962962963}*cell[17] + V{0.00462962962962963}*cell[18] + V{0.00462962962962963}*cell[19] + V{0.00462962962962963}*cell[1] + V{0.00462962962962963}*cell[20] + V{0.00462962962962963}*cell[21] + V{0.00462962962962963}*cell[22] + V{0.00462962962962963}*cell[23] + V{0.00462962962962963}*cell[24] + V{0.00462962962962963}*cell[25] + V{0.00462962962962963}*cell[26] + V{0.00462962962962963}*cell[2] + V{0.00462962962962963}*cell[3] + V{0.00462962962962963}*cell[4] + V{0.00462962962962963}*cell[5] + V{0.00462962962962963}*cell[6] + V{0.00462962962962963}*cell[7] + V{0.00462962962962963}*cell[8] + V{0.00462962962962963}*cell[9] + V{0.00462962962962963};
auto x196 = x156 + x174 + x186 + x45 + x88 + x97 + V{3}*cell[10] - V{3}*cell[23];
auto x197 = -x196;
auto x198 = x70 + x80;
auto x199 = x156 + x183 + x193 + x198 + x48 + x98 + V{3}*cell[11] - V{3}*cell[24];
auto x200 = x175 + x86;
auto x201 = x101 + x170 + x174 + x191 - x192 + x200 + x48 + cell[10] + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x202 = x138*x39;
auto x203 = x168 - x169 + x180 - x181 + x185 + x198 + x200 + x37 + x47 - V{3}*cell[13] - cell[1] + V{3}*cell[26];
auto x204 = -x203;
auto x205 = x147*x39;
auto x206 = x110*x83;
auto x207 = x110*x93 + V{-1};
auto x208 = x206 + x207;
auto x209 = x144*x39;
auto x210 = x110*x57;
auto x211 = x209 + x210;
auto x212 = x205 + x208 + x211;
auto x213 = x202 + x208;
auto x214 = x205 + x210;
auto x215 = x211 + x213;
auto x216 = -x139;
auto x217 = -x171;
auto x218 = x213 + x214;
auto x219 = -x184;
auto x220 = x121 + x148;
auto x221 = -x194;
auto x222 = -x199;
auto x223 = -x201;
auto x0 = -x108*(x121*(V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296}) + V{0.296296296296296}) + V{1}*x122*cell[0];
auto x1 = -x108*(x123*(-x112*x140 + x120 + x139) + V{0.0740740740740741}) + V{1}*x122*cell[1];
auto x2 = -x108*(x123*(-x115*x140 + x119 + x145 + x146) + V{0.0740740740740741}) + V{1}*x122*cell[2];
auto x3 = -x108*(x123*(x116 - x118*x140 + x146 + x148) + V{0.0740740740740741}) + V{1}*x122*cell[3];
auto x4 = -x108*(x149*(-x150*x159*x159 + x161) + V{0.0185185185185185}) + V{1}*x122*cell[4];
auto x5 = -x108*(x149*(-x150*x171*x171 + x173) + V{0.0185185185185185}) + V{1}*x122*cell[5];
auto x6 = -x108*(x149*(x148 - x150*x178*x178 + x160) + V{0.0185185185185185}) + V{1}*x122*cell[6];
auto x7 = -x108*(x149*(-x150*x184*x184 + x160 + x179) + V{0.0185185185185185}) + V{1}*x122*cell[7];
auto x8 = -x108*(x149*(-x150*x188*x188 + x190) + V{0.0185185185185185}) + V{1}*x122*cell[8];
auto x9 = -x108*(x149*(-x150*x194*x194 + x179 + x189) + V{0.0185185185185185}) + V{1}*x122*cell[9];
auto x10 = -x108*(x195*(x148 - x150*x197*x197 + x161) + V{0.00462962962962963}) + V{1}*x122*cell[10];
auto x11 = -x108*(x195*(-x150*x199*x199 + x161 + x179) + V{0.00462962962962963}) + V{1}*x122*cell[11];
auto x12 = -x108*(x195*(x148 - x150*x201*x201 + x173) + V{0.00462962962962963}) + V{1}*x122*cell[12];
auto x13 = -x108*(x195*(-x150*x204*x204 - x202 + x212) + V{0.00462962962962963}) + V{1}*x122*cell[13];
auto x14 = -x108*(x123*(-x140*x57 + x213) + V{0.0740740740740741}) + V{1}*x122*cell[14];
auto x15 = -x108*(x123*(-x140*x83 + x207 + x211) + V{0.0740740740740741}) + V{1}*x122*cell[15];
auto x16 = -x108*(x123*(-x140*x93 + x206 + x214 + V{-1}) + V{0.0740740740740741}) + V{1}*x122*cell[16];
auto x17 = -x108*(x149*(-x150*x158*x158 + x215) + V{0.0185185185185185}) + V{1}*x122*cell[17];
auto x18 = -x108*(x149*(-x150*x217*x217 + x189 + x216) + V{0.0185185185185185}) + V{1}*x122*cell[18];
auto x19 = -x108*(x149*(-x150*x177*x177 + x218) + V{0.0185185185185185}) + V{1}*x122*cell[19];
auto x20 = -x108*(x149*(-x150*x219*x219 + x216 + x220) + V{0.0185185185185185}) + V{1}*x122*cell[20];
auto x21 = -x108*(x149*(-x150*x187*x187 + x212) + V{0.0185185185185185}) + V{1}*x122*cell[21];
auto x22 = -x108*(x149*(-x150*x221*x221 + x172 + x220) + V{0.0185185185185185}) + V{1}*x122*cell[22];
auto x23 = -x108*(x195*(-x150*x196*x196 + x205 + x215) + V{0.00462962962962963}) + V{1}*x122*cell[23];
auto x24 = -x108*(x195*(-x150*x222*x222 - x205 + x215) + V{0.00462962962962963}) + V{1}*x122*cell[24];
auto x25 = -x108*(x195*(-x150*x223*x223 - x209 + x218) + V{0.00462962962962963}) + V{1}*x122*cell[25];
auto x26 = -x108*(x195*(-x150*x203*x203 + x190 + x216) + V{0.00462962962962963}) + V{1}*x122*cell[26];
cell.template getFieldPointer<olb::descriptors::AV_SHEAR>()[0] = x107;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { x38, V{1}*x109*(x57 + x83 + x93) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x33 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x32 = parameters.template get<olb::descriptors::LATTICE_TIME>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x30 = cell.template getFieldComponent<olb::descriptors::AV_SHEAR>(0);
auto x0 = cell[12] + cell[25];
auto x1 = x0 + cell[18];
auto x2 = cell[11] + cell[24];
auto x3 = x2 + cell[20];
auto x4 = cell[22] + cell[9];
auto x5 = cell[13] + cell[1];
auto x6 = cell[26] + cell[2] + cell[8];
auto x7 = cell[10] + cell[3];
auto x8 = V{1} / (x1 + x3 + x4 + x5 + x6 + x7 + cell[0] + cell[14] + cell[15] + cell[16] + cell[17] + cell[19] + cell[21] + cell[23] + cell[4] + cell[5] + cell[6] + cell[7] + V{1});
auto x9 = V{1}*x8;
auto x10 = -cell[17];
auto x11 = -cell[24];
auto x12 = x10 + x11 + cell[5];
auto x13 = -cell[19];
auto x14 = -cell[25];
auto x15 = x13 + x14 + cell[7];
auto x16 = -cell[23];
auto x17 = x16 - cell[26];
auto x18 = cell[10] + cell[11] + cell[4];
auto x19 = cell[12] + cell[6];
auto x20 = x12 + x15 + x17 + x18 + x19 + x5 - cell[14] - cell[18] - cell[20];
auto x21 = V{0.666666666666667}*cell[10];
auto x22 = V{0.666666666666667}*cell[11];
auto x23 = V{0.666666666666667}*cell[12];
auto x24 = V{0.666666666666667}*cell[13];
auto x25 = V{0.666666666666667}*cell[23];
auto x26 = V{0.666666666666667}*cell[24];
auto x27 = V{0.666666666666667}*cell[25];
auto x28 = V{0.666666666666667}*cell[26];
auto x29 = -V{0.333333333333333}*cell[0];
auto x34 = x21 + x22 + x23 + x24 + x25 + x26 + x27 + x28 + x29 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x35 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x36 = x34 + x35 - x9*x20*x20 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x37 = -cell[12];
auto x38 = -cell[13] - cell[21];
auto x39 = x16 + x38;
auto x40 = x10 + x11 + x18 + x37 + x39 + x6 - cell[15] + cell[18] - cell[22] + cell[25] - cell[5] + cell[9];
auto x41 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x42 = x34 + x41 - x9*x40*x40 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x43 = -cell[11];
auto x44 = x13 + x14 + x19 + x39 + x43 + x7 - cell[16] + cell[20] + cell[22] + cell[24] + cell[26] - cell[7] + cell[8] - cell[9];
auto x45 = x21 + x22 + x23 + x24 + x25 + x26 + x27 + x28 + x29 + x35 + x41 - x9*x44*x44 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x46 = x20*x8;
auto x47 = -cell[10];
auto x48 = x16 + x47 + cell[13] + cell[26];
auto x49 = x1 + x12 + x40*x46 + x43 + x48 - cell[4];
auto x50 = x15 + x3 + x37 + x44*x46 + x48 - cell[6];
auto x51 = x0 + x17 + x2 + x38 + x4 + x40*x44*x8 + x47 - cell[8];
auto x52 = V{1.4142135623731}*util::sqrt(V{0.5}*(x36*x36) + V{0.5}*(x42*x42) + V{0.5}*(x45*x45) + x49*x49 + x50*x50 + x51*x51);
return V{1} / (V{2.52268963608289}*util::sqrt(x8*(x52 - (x30*x32 + x52)/(x32 + V{1}))*(x33*x33) + V{0.0392836979096202}/((x31)*(x31))) + V{0.5}/x31);
}
 
};
 
 
template <typename... FIELDS>
struct ConSmagorinskyEffectiveOmega<BGK,descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x9 = cell[1] + cell[7];
auto x10 = x9 + cell[0] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8];
auto x11 = x10 + V{1};
auto x14 = V{1} / (x11);
auto x15 = V{1} / ((x11)*(x11));
auto x16 = x15/util::pow(x13, 4);
auto x17 = -cell[3];
auto x18 = -cell[5];
auto x19 = cell[1] - cell[7];
auto x20 = cell[2] - cell[6];
auto x21 = x18 + x19 + x20 + cell[3];
auto x22 = -x21;
auto x23 = -cell[4] + cell[8];
auto x24 = x17 + x18 + x23 + x9;
auto x25 = x14*x22*x24 + x17 + x19 + cell[5];
auto x26 = -x25;
auto x27 = x26*x26;
auto x28 = x27;
auto x29 = V{1}*x14;
auto x30 = x22*x22;
auto x31 = -x29*x30;
auto x32 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x33 = x32 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x34 = x31 + x33;
auto x35 = x34*x34;
auto x36 = x24*x24;
auto x37 = -x29*x36;
auto x38 = x32 + x37 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x39 = x38*x38;
auto x40 = V{0.5}*x39;
auto x41 = V{0.5}*x35 + x40;
auto x42 = util::sqrt(x28 + x41);
auto x43 = util::sqrt(x11*(V{1.4142135623731}*x42*(x13*x13) + (V{0.0392837100659193}*cell[0] + V{0.0392837100659193}*cell[1] + V{0.0392837100659193}*cell[2] + V{0.0392837100659193}*cell[3] + V{0.0392837100659193}*cell[4] + V{0.0392837100659193}*cell[5] + V{0.0392837100659193}*cell[6] + V{0.0392837100659193}*cell[7] + V{0.0392837100659193}*cell[8] + V{0.0392837100659193})/((x12)*(x12))));
auto x44 = V{1} / (x12);
auto x45 = x43 - x44*(V{0.198201185833787}*cell[0] + V{0.198201185833787}*cell[1] + V{0.198201185833787}*cell[2] + V{0.198201185833787}*cell[3] + V{0.198201185833787}*cell[4] + V{0.198201185833787}*cell[5] + V{0.198201185833787}*cell[6] + V{0.198201185833787}*cell[7] + V{0.198201185833787}*cell[8] + V{0.198201185833787});
auto x46 = -x45;
auto x47 = V{1} / (x42);
auto x48 = -V{0.140149402542286}*x43 + V{0.166666666666667}*x44*(V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667});
auto x49 = x31 + x37 - V{0.666666666666667}*cell[0] + V{1.33333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{1.33333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{1.33333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{1.33333333333333}*cell[7] + V{0.333333333333333}*cell[8];
auto x50 = V{13.4543468074917}*x14*x47*x48*x49*util::sqrt(x16*(x46*x46)*(x41 + x27)/(V{2}*x28 + x35 + x39)) + V{1};
auto x51 = x25*x25;
auto x52 = x21*x21;
auto x53 = -x29*x52 + x33;
auto x54 = x53*x53;
auto x55 = util::sqrt(x16*(x45*x45)*V{1} / (x39 + x54 + V{2}*x51)*(x40 + V{0.5}*x54 + x51));
auto x56 = x10 + V{1};
auto x57 = V{1.5}*x15;
auto x58 = x36*x57;
auto x59 = x30*x57 + V{-1};
auto x60 = x58 + x59;
auto x61 = V{0.373731855763657}*x14;
auto x62 = V{4.5}*x15;
auto x63 = x20 + x23 + V{2}*cell[1] - V{2}*cell[5];
auto x64 = -x63;
auto x65 = V{3}*cell[3];
auto x66 = V{3}*cell[7];
auto x67 = V{3}*cell[1] - V{3}*cell[5];
auto x68 = x65 - x66 + x67 + V{3}*cell[2] - V{3}*cell[6];
auto x69 = x14*x68;
auto x70 = -x58 + x69 + V{1};
auto x71 = x14*(-x65 + x66 + x67 - V{3}*cell[4] + V{3}*cell[8]);
auto x72 = x52*x57;
auto x73 = x71 - x72;
auto x74 = V{1.49492742305463}*x14;
auto x75 = V{3}*x15;
auto x76 = -x20 - V{2}*cell[3] - cell[4] + V{2}*cell[7] + cell[8];
auto x77 = -x62*x76*x76;
auto x78 = x36*x75;
auto x79 = x58 + x69 + V{-1};
auto x80 = x72 + x79;
cell[0] = V{5.97970969221852}*x14*x47*x48*x49*x55*(x56*x60 + V{1}) + x50*cell[0];
cell[1] = -x47*x48*x49*x55*x61*(x56*(x62*(x64*x64) + x70 + x73) + V{-1}) + x50*cell[1];
cell[2] = -x47*x48*x49*x55*x74*(x56*(x52*x75 + x70) + V{-1}) + x50*cell[2];
cell[3] = x47*x48*x49*x55*x61*(x56*(-x14*x68 + x60 + x71 + x77) + V{1}) + x50*cell[3];
cell[4] = x47*x48*x49*x55*x74*(x56*(x59 + x71 - x78) + V{1}) + x50*cell[4];
cell[5] = -x47*x48*x49*x55*x61*(-x56*(-V{4.5}*x15*x63*x63 + x71 + x80) + V{-1}) + x50*cell[5];
cell[6] = -x47*x48*x49*x55*x74*(x56*(V{3}*x15*x52 - x79) + V{-1}) + x50*cell[6];
cell[7] = -x47*x48*x49*x55*x61*(x56*(x71 - x77 - x80) + V{-1}) + x50*cell[7];
cell[8] = -x47*x48*x49*x55*x74*(x56*(x73 + x78 + V{1}) + V{-1}) + x50*cell[8];
return { x11, V{1}*x15*(x36 + x52) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = cell[1] + cell[7] + cell[8];
auto x1 = x0 + cell[0] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + V{1};
auto x2 = V{1} / (x1);
auto x3 = (V{0.0392837100659193}*cell[0] + V{0.0392837100659193}*cell[1] + V{0.0392837100659193}*cell[2] + V{0.0392837100659193}*cell[3] + V{0.0392837100659193}*cell[4] + V{0.0392837100659193}*cell[5] + V{0.0392837100659193}*cell[6] + V{0.0392837100659193}*cell[7] + V{0.0392837100659193}*cell[8] + V{0.0392837100659193})/((x12)*(x12));
auto x4 = x13*x13;
auto x5 = -cell[3];
auto x6 = cell[1] - cell[7];
auto x7 = -cell[5];
auto x8 = x7 + cell[3];
auto x9 = x6 + x8 + cell[2] - cell[6];
auto x10 = -x9;
auto x11 = x0 + x5 + x7 - cell[4];
auto x14 = x11*x2;
auto x15 = x10*x14 + x5 + x6 + cell[5];
auto x16 = V{1}*x2;
auto x17 = -x16*x9*x9;
auto x18 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x19 = x18 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x20 = x17 + x19;
auto x21 = x20*x20;
auto x22 = -x16*x11*x11;
auto x23 = x18 + x22 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x24 = x23*x23;
auto x25 = V{0.5}*x24;
auto x26 = V{0.5}*x21 + x25;
auto x27 = util::sqrt(x26 + x15*x15);
auto x28 = V{1} / (x12);
auto x29 = -x28*(V{0.198201185833787}*cell[0] + V{0.198201185833787}*cell[1] + V{0.198201185833787}*cell[2] + V{0.198201185833787}*cell[3] + V{0.198201185833787}*cell[4] + V{0.198201185833787}*cell[5] + V{0.198201185833787}*cell[6] + V{0.198201185833787}*cell[7] + V{0.198201185833787}*cell[8] + V{0.198201185833787}) + util::sqrt(x1*(V{1.4142135623731}*x27*x4 + x3));
auto x30 = -x14*x9 - x8 + cell[1] - cell[7];
auto x31 = x30*x30;
auto x32 = -x16*x10*x10 + x19;
auto x33 = -x15;
return V{13.4543468074917}*x2*(x17 + x22 - V{0.666666666666667}*cell[0] + V{1.33333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{1.33333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{1.33333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{1.33333333333333}*cell[7] + V{0.333333333333333}*cell[8])*util::sqrt((x29*x29)*V{1} / (x21 + x24 + V{2}*x31)*(x26 + x31)/(((x1)*(x1))*util::pow(x13, 4)))*(-V{0.166666666666667}*x28*(V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}) + V{0.140149402542286}*util::sqrt(x1*(x3 + V{1.4142135623731}*x4*util::sqrt(x25 + V{0.5}*(x32*x32) + x33*x33))))/x27;
}
 
};
 
template <typename... FIELDS>
struct ConSmagorinskyEffectiveOmega<BGK,descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x24 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x19 = cell[13] + cell[15];
auto x20 = x19 + cell[10];
auto x21 = cell[11] + cell[5];
auto x22 = cell[12] + cell[7] + cell[9];
auto x25 = cell[2] + cell[8];
auto x26 = cell[18] + cell[3];
auto x27 = cell[16] + cell[6];
auto x28 = x20 + x21 + x22 + x25 + x26 + x27 + cell[0] + cell[14] + cell[17] + cell[1] + cell[4];
auto x29 = x28 + V{1};
auto x30 = V{1} / (x29);
auto x31 = V{1} / ((x29)*(x29));
auto x32 = x31/util::pow(x24, 4);
auto x33 = V{1}*x30;
auto x34 = -cell[1];
auto x35 = -cell[7];
auto x36 = -cell[6];
auto x37 = x36 + cell[16];
auto x38 = x34 + x35 + x37;
auto x39 = -cell[4];
auto x40 = x39 + cell[14];
auto x41 = x40 - cell[5];
auto x42 = x20 + x38 + x41;
auto x43 = x42*x42;
auto x44 = x33*x43;
auto x45 = V{0.333333333333333}*cell[0];
auto x46 = x45 + V{0.333333333333333}*cell[12] - V{0.666666666666667}*cell[13] - V{0.666666666666667}*cell[14] + V{0.333333333333333}*cell[3] - V{0.666666666666667}*cell[4] - V{0.666666666666667}*cell[5];
auto x47 = V{0.333333333333333}*cell[11] - V{0.666666666666667}*cell[15] - V{0.666666666666667}*cell[16] + V{0.333333333333333}*cell[2] - V{0.666666666666667}*cell[6] - V{0.666666666666667}*cell[7];
auto x48 = -x44 - x46 - x47 + V{0.666666666666667}*cell[10] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x49 = cell[13] + cell[17];
auto x50 = -cell[2];
auto x51 = -cell[9];
auto x52 = -cell[8];
auto x53 = x52 + cell[18];
auto x54 = x50 + x51 + x53;
auto x55 = x21 + x39 - cell[14];
auto x56 = x49 + x54 + x55;
auto x57 = x56*x56;
auto x58 = x33*x57;
auto x59 = V{0.333333333333333}*cell[10] - V{0.666666666666667}*cell[17] - V{0.666666666666667}*cell[18] + V{0.333333333333333}*cell[1] - V{0.666666666666667}*cell[8] - V{0.666666666666667}*cell[9];
auto x60 = -x46 - x58 - x59 + V{0.666666666666667}*cell[11] - V{0.333333333333333}*cell[15] - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x61 = cell[15] + cell[17];
auto x62 = -cell[3];
auto x63 = -cell[18];
auto x64 = x52 + x62 + x63;
auto x65 = x36 - cell[16];
auto x66 = x22 + x61 + x64 + x65;
auto x67 = x66*x66;
auto x68 = x33*x67;
auto x69 = -x45 - x47 - x59 - x68 + V{0.666666666666667}*cell[12] - V{0.333333333333333}*cell[13] - V{0.333333333333333}*cell[14] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x70 = x30*x42;
auto x71 = -x40 - x56*x70 + cell[13] - cell[5];
auto x72 = -cell[15];
auto x73 = -x37 - x66*x70 - x72 - cell[7];
auto x74 = -cell[17];
auto x75 = x74 + cell[9];
auto x76 = -x30*x56*x66 - x53 - x75;
auto x77 = util::sqrt(V{0.5}*(x48*x48) + V{0.5}*(x60*x60) + V{0.5}*(x69*x69) + x71*x71 + x73*x73 + x76*x76);
auto x78 = x29*(x77*(x24*x24) + (V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778})/((x23)*(x23)));
auto x79 = V{1} / (x23);
auto x80 = V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{0.166666666666667};
auto x81 = util::sqrt(x78) - x79*x80;
auto x82 = -x81;
auto x83 = V{1} / (x77);
auto x84 = -V{0.166666666666667}*util::sqrt(x78) + V{0.166666666666667}*x79*x80;
auto x85 = -x44 - x58 - x68 - V{1}*cell[0] + V{1.11022302462516e-16}*cell[10] + V{1.11022302462516e-16}*cell[11] + V{1.11022302462516e-16}*cell[12] + V{1}*cell[13] + V{1}*cell[14] + V{1}*cell[15] + V{1}*cell[16] + V{1}*cell[17] + V{1}*cell[18] + V{1.11022302462516e-16}*cell[1] + V{1.11022302462516e-16}*cell[2] + V{1.11022302462516e-16}*cell[3] + V{1}*cell[4] + V{1}*cell[5] + V{1}*cell[6] + V{1}*cell[7] + V{1}*cell[8] + V{1}*cell[9];
auto x86 = V{8.485284}*x30*x83*x84*x85*util::sqrt(x32*(x82*x82)) + V{1};
auto x87 = util::sqrt(x32*(x81*x81));
auto x88 = x28 + V{1};
auto x89 = V{1.5}*x31;
auto x90 = x43*x89;
auto x91 = x57*x89;
auto x92 = x67*x89;
auto x93 = x91 + x92 + V{-1};
auto x94 = x90 + x93;
auto x95 = V{0.471404666666667}*x30;
auto x96 = V{3}*cell[14];
auto x97 = V{3}*cell[16];
auto x98 = V{3}*cell[5];
auto x99 = V{3}*cell[7];
auto x100 = V{3}*cell[13] - V{3}*cell[4];
auto x101 = V{3}*cell[15] - V{3}*cell[6];
auto x102 = x30*(x100 + x101 + x96 + x97 - x98 - x99 + V{3}*cell[10] - V{3}*cell[1]);
auto x103 = V{3}*x31;
auto x104 = x103*x43;
auto x105 = V{3}*cell[18];
auto x106 = V{3}*cell[9];
auto x107 = V{3}*cell[17] - V{3}*cell[8];
auto x108 = x30*(x100 + x105 - x106 + x107 - x96 + x98 + V{3}*cell[11] - V{3}*cell[2]);
auto x109 = x103*x57;
auto x110 = x90 + V{-1};
auto x111 = x30*(x101 - x105 + x106 + x107 - x97 + x99 + V{3}*cell[12] - V{3}*cell[3]);
auto x112 = x103*x67;
auto x113 = V{0.235702333333333}*x30;
auto x114 = V{4.5}*x31;
auto x115 = x38 + cell[10];
auto x116 = x115 + x54 + x61 + cell[11] + V{2}*cell[13] - V{2}*cell[4];
auto x117 = x114*(x116*x116);
auto x118 = x102 + x94;
auto x119 = -x108;
auto x120 = x115 + x25 + x63 + x75 - cell[11] + V{2}*cell[14] + cell[15] - V{2}*cell[5];
auto x121 = -x120;
auto x122 = x34 + x41 + cell[10];
auto x123 = x122 + x49 + x64 + cell[12] + V{2}*cell[15] - V{2}*cell[6] + cell[9];
auto x124 = x114*(x123*x123);
auto x125 = -x111;
auto x126 = -cell[12] + cell[13];
auto x127 = x122 + x126 + x26 + x51 + x74 + V{2}*cell[16] - V{2}*cell[7] + cell[8];
auto x128 = -x127;
auto x129 = x50 + x55;
auto x130 = x129 + x19 + x62 + x65 + cell[12] + V{2}*cell[17] + cell[7] - V{2}*cell[8];
auto x131 = x114*(x130*x130);
auto x132 = x108 + x94;
auto x133 = x126 + x129 + x27 + x35 + x72 + V{2}*cell[18] + cell[3] - V{2}*cell[9];
auto x134 = -x133;
auto x135 = -x91;
auto x136 = V{1} - x92;
auto x137 = x135 + x136;
auto x138 = x102 + x137;
auto x139 = -x90;
auto x140 = x108 + x139;
auto x141 = x111 + x139;
auto x142 = -x102;
auto x143 = x111 + x94;
cell[0] = V{2.828428}*x30*x83*x84*x85*x87*(x88*x94 + V{1}) + x86*cell[0];
cell[1] = x83*x84*x85*x87*x95*(x88*(x102 - x104 + x93) + V{1}) + x86*cell[1];
cell[2] = x83*x84*x85*x87*x95*(x88*(x108 - x109 + x110 + x92) + V{1}) + x86*cell[2];
cell[3] = x83*x84*x85*x87*x95*(x88*(x110 + x111 - x112 + x91) + V{1}) + x86*cell[3];
cell[4] = x113*x83*x84*x85*x87*(x88*(x108 - x117 + x118) + V{1}) + x86*cell[4];
cell[5] = x113*x83*x84*x85*x87*(x88*(-x114*x121*x121 + x118 + x119) + V{1}) + x86*cell[5];
cell[6] = x113*x83*x84*x85*x87*(x88*(x111 + x118 - x124) + V{1}) + x86*cell[6];
cell[7] = x113*x83*x84*x85*x87*(x88*(-x114*x128*x128 + x118 + x125) + V{1}) + x86*cell[7];
cell[8] = x113*x83*x84*x85*x87*(x88*(x111 - x131 + x132) + V{1}) + x86*cell[8];
cell[9] = x113*x83*x84*x85*x87*(x88*(-x114*x134*x134 + x125 + x132) + V{1}) + x86*cell[9];
cell[10] = -x83*x84*x85*x87*x95*(x88*(x104 + x138) + V{-1}) + x86*cell[10];
cell[11] = -x83*x84*x85*x87*x95*(x88*(x109 + x136 + x140) + V{-1}) + x86*cell[11];
cell[12] = -x83*x84*x85*x87*x95*(x88*(x112 + x135 + x141 + V{1}) + V{-1}) + x86*cell[12];
cell[13] = -x113*x83*x84*x85*x87*(x88*(x117 + x138 + x140) + V{-1}) + x86*cell[13];
cell[14] = x113*x83*x84*x85*x87*(x88*(-x114*x120*x120 + x132 + x142) + V{1}) + x86*cell[14];
cell[15] = -x113*x83*x84*x85*x87*(x88*(x124 + x138 + x141) + V{-1}) + x86*cell[15];
cell[16] = x113*x83*x84*x85*x87*(x88*(-x114*x127*x127 + x142 + x143) + V{1}) + x86*cell[16];
cell[17] = -x113*x83*x84*x85*x87*(x88*(x111 + x131 + x137 + x140) + V{-1}) + x86*cell[17];
cell[18] = x113*x83*x84*x85*x87*(x88*(-x114*x133*x133 + x119 + x143) + V{1}) + x86*cell[18];
return { x29, V{1}*x31*(x43 + x57 + x67) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x24 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x0 = cell[12] + cell[15] + cell[17];
auto x1 = cell[11] + cell[13] + cell[18];
auto x2 = cell[10] + cell[14] + cell[16];
auto x3 = x0 + x1 + x2 + cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1};
auto x4 = V{1} / (x3);
auto x5 = (V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778})/((x23)*(x23));
auto x6 = x24*x24;
auto x7 = V{1}*x4;
auto x8 = -cell[6];
auto x9 = x8 + cell[7];
auto x10 = -cell[8];
auto x11 = x10 + cell[9];
auto x12 = x0 + x11 + x9 - cell[16] - cell[18] - cell[3];
auto x13 = x7*(x12*x12);
auto x14 = V{0.333333333333333}*cell[0];
auto x15 = x14 + V{0.333333333333333}*cell[10] - V{0.666666666666667}*cell[17] - V{0.666666666666667}*cell[18] + V{0.333333333333333}*cell[1] - V{0.666666666666667}*cell[8] - V{0.666666666666667}*cell[9];
auto x16 = V{0.333333333333333}*cell[11] - V{0.666666666666667}*cell[15] - V{0.666666666666667}*cell[16] + V{0.333333333333333}*cell[2] - V{0.666666666666667}*cell[6] - V{0.666666666666667}*cell[7];
auto x17 = x13 + x15 + x16 - V{0.666666666666667}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] - V{0.666666666666667}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5];
auto x18 = -cell[4];
auto x19 = x18 + cell[5];
auto x20 = x1 + x10 + x19 - cell[14] + cell[17] - cell[2] - cell[9];
auto x21 = x7*(x20*x20);
auto x22 = V{0.333333333333333}*cell[12] - V{0.666666666666667}*cell[13] - V{0.666666666666667}*cell[14] + V{0.333333333333333}*cell[3] - V{0.666666666666667}*cell[4] - V{0.666666666666667}*cell[5];
auto x25 = x15 + x21 + x22 - V{0.666666666666667}*cell[11] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] - V{0.666666666666667}*cell[2] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7];
auto x26 = x18 + x2 + x8 + cell[13] + cell[15] - cell[1] - cell[5] - cell[7];
auto x27 = x7*(x26*x26);
auto x28 = x14 + x16 + x22 + x27 - V{0.666666666666667}*cell[10] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] - V{0.666666666666667}*cell[1] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9];
auto x29 = x26*x4;
auto x30 = x19 + x20*x29 - cell[13] + cell[14];
auto x31 = x12*x29 + x9 - cell[15] + cell[16];
auto x32 = x11 + x12*x20*x4 - cell[17] + cell[18];
auto x33 = util::sqrt(V{0.5}*(x17*x17) + V{0.5}*(x25*x25) + V{0.5}*(x28*x28) + x30*x30 + x31*x31 + x32*x32);
auto x34 = (V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{0.166666666666667})/x23;
auto x35 = -x34 + util::sqrt(x3*(x33*x6 + x5));
auto x36 = -x28;
auto x37 = -x25;
auto x38 = -x17;
auto x39 = -x30;
auto x40 = -x31;
auto x41 = -x32;
return -V{8.485284}*x4*(x13 + x21 + x27 + V{1}*cell[0] - V{1.11022302462516e-16}*cell[10] - V{1.11022302462516e-16}*cell[11] - V{1.11022302462516e-16}*cell[12] - V{1}*cell[13] - V{1}*cell[14] - V{1}*cell[15] - V{1}*cell[16] - V{1}*cell[17] - V{1}*cell[18] - V{1.11022302462516e-16}*cell[1] - V{1.11022302462516e-16}*cell[2] - V{1.11022302462516e-16}*cell[3] - V{1}*cell[4] - V{1}*cell[5] - V{1}*cell[6] - V{1}*cell[7] - V{1}*cell[8] - V{1}*cell[9])*util::sqrt((x35*x35)/(util::pow(x24, 4)*((x3)*(x3))))*(-V{0.166666666666667}*x34 + V{0.166666666666667}*util::sqrt(x3*(x5 + x6*util::sqrt(V{0.5}*(x36*x36) + V{0.5}*(x37*x37) + V{0.5}*(x38*x38) + x39*x39 + x40*x40 + x41*x41))))/x33;
}
 
};
 
template <typename... FIELDS>
struct ConSmagorinskyEffectiveOmega<BGK,descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x32 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x27 = cell[10] + cell[6];
auto x28 = x27 + cell[13];
auto x29 = cell[12] + cell[26];
auto x30 = cell[15] + cell[21];
auto x33 = cell[19] + cell[7];
auto x34 = cell[24] + cell[25];
auto x35 = x34 + cell[14];
auto x36 = x28 + x29 + x30 + x33 + x35 + cell[0] + cell[11] + cell[16] + cell[17] + cell[18] + cell[1] + cell[20] + cell[22] + cell[23] + cell[2] + cell[3] + cell[4] + cell[5] + cell[8] + cell[9];
auto x37 = x36 + V{1};
auto x38 = V{1} / (x37);
auto x39 = V{1} / ((x37)*(x37));
auto x40 = x39/util::pow(x32, 4);
auto x41 = V{1}*x38;
auto x42 = -cell[24];
auto x43 = -cell[19];
auto x44 = x43 + cell[7];
auto x45 = -cell[25];
auto x46 = x45 + cell[11];
auto x47 = x44 + x46;
auto x48 = -cell[23];
auto x49 = -cell[26];
auto x50 = x48 + x49 + cell[12];
auto x51 = -cell[20];
auto x52 = x51 + cell[4];
auto x53 = -cell[17];
auto x54 = x53 + cell[5];
auto x55 = -cell[14] + cell[1];
auto x56 = x54 + x55 - cell[18];
auto x57 = x28 + x42 + x47 + x50 + x52 + x56;
auto x58 = -x57;
auto x59 = x58*x58;
auto x60 = -x41*x59;
auto x61 = V{0.666666666666667}*cell[10];
auto x62 = V{0.666666666666667}*cell[11];
auto x63 = V{0.666666666666667}*cell[12];
auto x64 = V{0.666666666666667}*cell[13];
auto x65 = V{0.666666666666667}*cell[23];
auto x66 = V{0.666666666666667}*cell[24];
auto x67 = V{0.666666666666667}*cell[25];
auto x68 = V{0.666666666666667}*cell[26];
auto x69 = -V{0.333333333333333}*cell[0];
auto x70 = x61 + x62 + x63 + x64 + x65 + x66 + x67 + x68 + x69 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x71 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x72 = x60 + x70 + x71 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x73 = -cell[12];
auto x74 = x73 + cell[26];
auto x75 = -cell[13];
auto x76 = -cell[21];
auto x77 = x76 + cell[9];
auto x78 = x75 + x77 + cell[11];
auto x79 = x48 + cell[8];
auto x80 = -cell[22];
auto x81 = x80 + cell[4];
auto x82 = -cell[15] + cell[2];
auto x83 = x82 + cell[10];
auto x84 = x53 + cell[18] - cell[5];
auto x85 = x42 + x74 + x78 + x79 + x81 + x83 + x84 + cell[25];
auto x86 = -x85;
auto x87 = x86*x86;
auto x88 = -x41*x87;
auto x89 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x90 = x70 + x88 + x89 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x91 = -cell[11];
auto x92 = -cell[16];
auto x93 = x75 + x92 + cell[3];
auto x94 = -cell[9];
auto x95 = x76 + x94 + cell[22];
auto x96 = x43 + cell[20] - cell[7];
auto x97 = x27 + x29 + x45 + x79 + x91 + x93 + x95 + x96 + cell[24];
auto x98 = -x97;
auto x99 = x98*x98;
auto x100 = -x41*x99;
auto x101 = x100 + x61 + x62 + x63 + x64 + x65 + x66 + x67 + x68 + x69 + x71 + x89 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x102 = -cell[10];
auto x103 = x38*x58;
auto x104 = x42 + cell[12] + cell[26];
auto x105 = x48 + cell[13] + cell[25];
auto x106 = -x102 - x103*x86 - x104 - x105 - x54 - x91 - cell[18] + cell[4];
auto x107 = -cell[6];
auto x108 = x48 + cell[13] + cell[24];
auto x109 = -x102 - x103*x98 - x107 - x108 - x47 - x74 - cell[20];
auto x110 = -cell[8];
auto x111 = x110 + cell[22];
auto x112 = -x102 - x111 - x34 - x38*x86*x98 - x50 - x78;
auto x113 = util::sqrt(V{0.5}*(x101*x101) + x106*x106 + x109*x109 + x112*x112 + V{0.5}*(x72*x72) + V{0.5}*(x90*x90));
auto x114 = x37*(x113*(x32*x32) + (V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[19] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[20] + V{0.0277777777777778}*cell[21] + V{0.0277777777777778}*cell[22] + V{0.0277777777777778}*cell[23] + V{0.0277777777777778}*cell[24] + V{0.0277777777777778}*cell[25] + V{0.0277777777777778}*cell[26] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778})/((x31)*(x31)));
auto x115 = V{1} / (x31);
auto x116 = V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[19] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[20] + V{0.166666666666667}*cell[21] + V{0.166666666666667}*cell[22] + V{0.166666666666667}*cell[23] + V{0.166666666666667}*cell[24] + V{0.166666666666667}*cell[25] + V{0.166666666666667}*cell[26] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{0.166666666666667};
auto x117 = util::sqrt(x114) - x115*x116;
auto x118 = -x117;
auto x119 = V{1} / (x113);
auto x120 = -V{0.166666666666667}*util::sqrt(x114) + V{0.166666666666667}*x115*x116;
auto x121 = x100 + x60 + x88 - V{1}*cell[0] + V{2}*cell[10] + V{2}*cell[11] + V{2}*cell[12] + V{2}*cell[13] + V{1.11022302462516e-16}*cell[14] + V{1.11022302462516e-16}*cell[15] + V{1.11022302462516e-16}*cell[16] + V{1}*cell[17] + V{1}*cell[18] + V{1}*cell[19] + V{1.11022302462516e-16}*cell[1] + V{1}*cell[20] + V{1}*cell[21] + V{1}*cell[22] + V{2}*cell[23] + V{2}*cell[24] + V{2}*cell[25] + V{2}*cell[26] + V{1.11022302462516e-16}*cell[2] + V{1.11022302462516e-16}*cell[3] + V{1}*cell[4] + V{1}*cell[5] + V{1}*cell[6] + V{1}*cell[7] + V{1}*cell[8] + V{1}*cell[9];
auto x122 = V{7.54247466666667}*x119*x120*x121*x38*util::sqrt(x40*(x118*x118)) + V{1};
auto x123 = util::sqrt(x40*(x117*x117));
auto x124 = x36 + V{1};
auto x125 = V{1.5}*x39;
auto x126 = x125*x59;
auto x127 = x125*x87;
auto x128 = x125*x99;
auto x129 = x127 + x128 + V{-1};
auto x130 = x126 + x129;
auto x131 = V{0.558701827160494}*x38;
auto x132 = V{3}*cell[5];
auto x133 = V{3}*cell[7];
auto x134 = V{3}*cell[13];
auto x135 = V{3}*cell[18];
auto x136 = V{3}*cell[20];
auto x137 = V{3}*cell[26];
auto x138 = V{3}*cell[10];
auto x139 = V{3}*cell[11];
auto x140 = -V{3}*cell[23];
auto x141 = V{3}*cell[24];
auto x142 = x138 + x139 + x140 - x141 - V{3}*cell[17] + V{3}*cell[4];
auto x143 = V{3}*cell[12];
auto x144 = V{3}*cell[25];
auto x145 = x143 - x144 - V{3}*cell[19] + V{3}*cell[6];
auto x146 = x132 + x133 + x134 - x135 - x136 - x137 + x142 + x145 - V{3}*cell[14] + V{3}*cell[1];
auto x147 = -x146*x38;
auto x148 = V{3}*x39;
auto x149 = V{3}*cell[9];
auto x150 = V{3}*cell[22];
auto x151 = -x134 + x137 - V{3}*cell[21] + V{3}*cell[8];
auto x152 = -x132 + x135 + x142 - x143 + x144 + x149 - x150 + x151 - V{3}*cell[15] + V{3}*cell[2];
auto x153 = -x152*x38;
auto x154 = x126 + V{-1};
auto x155 = -x133 + x136 + x138 - x139 + x140 + x141 + x145 - x149 + x150 + x151 - V{3}*cell[16] + V{3}*cell[3];
auto x156 = -x155*x38;
auto x157 = V{0.139675456790123}*x38;
auto x158 = V{4.5}*x39;
auto x159 = -V{2}*cell[23];
auto x160 = V{2}*cell[10];
auto x161 = x159 + x160 + cell[8];
auto x162 = V{2}*cell[11] - V{2}*cell[24];
auto x163 = x162 + x82;
auto x164 = x55 - V{2}*cell[17] + V{2}*cell[4];
auto x165 = x44 + x51 + cell[6];
auto x166 = x161 + x163 + x164 + x165 + x77 + x80;
auto x167 = -x166;
auto x168 = x130 + x147;
auto x169 = x153 + x168;
auto x170 = V{2}*cell[25];
auto x171 = V{2}*cell[12];
auto x172 = -x170 + x171;
auto x173 = V{2}*cell[26];
auto x174 = V{2}*cell[13];
auto x175 = -x173 + x174;
auto x176 = V{2}*cell[18];
auto x177 = V{2}*cell[5];
auto x178 = -x176 + x177 + x55 - cell[2];
auto x179 = x111 + x165 + x172 + x175 + x178 + x30 + x94;
auto x180 = -x153;
auto x181 = x168 + x180;
auto x182 = -V{2}*cell[19] + V{2}*cell[6];
auto x183 = x92 + cell[3];
auto x184 = x183 + cell[4];
auto x185 = x161 + x172 + x182 + x184 + x56 + x95;
auto x186 = -x185;
auto x187 = -x156;
auto x188 = V{2}*cell[20];
auto x189 = V{2}*cell[7];
auto x190 = cell[16] - cell[3];
auto x191 = -x188 + x189 + x190;
auto x192 = x110 + x162 + x175 + x191 + x56 + x81 + cell[21] + cell[9];
auto x193 = -V{2}*cell[21] + V{2}*cell[8];
auto x194 = x193 + x82;
auto x195 = x159 + x160 + x173 - x174 + x184 + x194 + x84 + x96 + cell[6];
auto x196 = -x195;
auto x197 = x130 + x153;
auto x198 = x156 + x197;
auto x199 = V{2}*cell[22];
auto x200 = V{2}*cell[9];
auto x201 = -x199 + x200;
auto x202 = x107 + x163 + x170 - x171 + x190 + x201 + x33 + x52 + x84;
auto x203 = V{0.0349188641975309}*x38;
auto x204 = x104 + x164 + x182 + x194 + x46 + x93 + V{3}*cell[10] - V{3}*cell[23];
auto x205 = -x204;
auto x206 = x73 + x83;
auto x207 = x105 + x164 + x191 + x201 + x206 + x49 + V{3}*cell[11] - V{3}*cell[24];
auto x208 = x183 + x91;
auto x209 = x108 + x178 + x182 + x199 - x200 + x208 + x49 + cell[10] + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x210 = x146*x38;
auto x211 = x176 - x177 + x188 - x189 + x193 + x206 + x208 + x35 + x48 - V{3}*cell[13] - cell[1] + V{3}*cell[26];
auto x212 = -x211;
auto x213 = x155*x38;
auto x214 = x85*x85;
auto x215 = x125*x214;
auto x216 = x97*x97;
auto x217 = x125*x216 + V{-1};
auto x218 = x215 + x217;
auto x219 = x152*x38;
auto x220 = x57*x57;
auto x221 = x125*x220;
auto x222 = x219 + x221;
auto x223 = x213 + x218 + x222;
auto x224 = x210 + x218;
auto x225 = x213 + x221;
auto x226 = x222 + x224;
auto x227 = -x147;
auto x228 = -x179;
auto x229 = x224 + x225;
auto x230 = -x192;
auto x231 = x130 + x156;
auto x232 = -x202;
auto x233 = -x207;
auto x234 = -x209;
cell[0] = V{2.23480730864198}*x119*x120*x121*x123*x38*(x124*x130 + V{1}) + x122*cell[0];
cell[1] = x119*x120*x121*x123*x131*(x124*(x129 + x147 - x148*x59) + V{1}) + x122*cell[1];
cell[2] = x119*x120*x121*x123*x131*(x124*(x128 - x148*x87 + x153 + x154) + V{1}) + x122*cell[2];
cell[3] = x119*x120*x121*x123*x131*(x124*(x127 - x148*x99 + x154 + x156) + V{1}) + x122*cell[3];
cell[4] = x119*x120*x121*x123*x157*(x124*(-x158*x167*x167 + x169) + V{1}) + x122*cell[4];
cell[5] = x119*x120*x121*x123*x157*(x124*(-x158*x179*x179 + x181) + V{1}) + x122*cell[5];
cell[6] = x119*x120*x121*x123*x157*(x124*(x156 - x158*x186*x186 + x168) + V{1}) + x122*cell[6];
cell[7] = x119*x120*x121*x123*x157*(x124*(-x158*x192*x192 + x168 + x187) + V{1}) + x122*cell[7];
cell[8] = x119*x120*x121*x123*x157*(x124*(-x158*x196*x196 + x198) + V{1}) + x122*cell[8];
cell[9] = x119*x120*x121*x123*x157*(x124*(-x158*x202*x202 + x187 + x197) + V{1}) + x122*cell[9];
cell[10] = x119*x120*x121*x123*x203*(x124*(x156 - x158*x205*x205 + x169) + V{1}) + x122*cell[10];
cell[11] = x119*x120*x121*x123*x203*(x124*(-x158*x207*x207 + x169 + x187) + V{1}) + x122*cell[11];
cell[12] = x119*x120*x121*x123*x203*(x124*(x156 - x158*x209*x209 + x181) + V{1}) + x122*cell[12];
cell[13] = -x119*x120*x121*x123*x203*(-x124*(-x210 + x223 - V{4.5}*x39*x212*x212) + V{-1}) + x122*cell[13];
cell[14] = -x119*x120*x121*x123*x131*(x124*(V{3}*x220*x39 - x224) + V{-1}) + x122*cell[14];
cell[15] = -x119*x120*x121*x123*x131*(x124*(V{3}*x214*x39 - x217 - x222) + V{-1}) + x122*cell[15];
cell[16] = -x119*x120*x121*x123*x131*(x124*(-x215 + V{3}*x216*x39 - x225 + V{1}) + V{-1}) + x122*cell[16];
cell[17] = -x119*x120*x121*x123*x157*(-x124*(x226 - V{4.5}*x39*x166*x166) + V{-1}) + x122*cell[17];
cell[18] = x119*x120*x121*x123*x157*(x124*(-x158*x228*x228 + x197 + x227) + V{1}) + x122*cell[18];
cell[19] = -x119*x120*x121*x123*x157*(-x124*(x229 - V{4.5}*x39*x185*x185) + V{-1}) + x122*cell[19];
cell[20] = x119*x120*x121*x123*x157*(x124*(-x158*x230*x230 + x227 + x231) + V{1}) + x122*cell[20];
cell[21] = -x119*x120*x121*x123*x157*(-x124*(x223 - V{4.5}*x39*x195*x195) + V{-1}) + x122*cell[21];
cell[22] = x119*x120*x121*x123*x157*(x124*(-x158*x232*x232 + x180 + x231) + V{1}) + x122*cell[22];
cell[23] = -x119*x120*x121*x123*x203*(-x124*(x213 + x226 - V{4.5}*x39*x204*x204) + V{-1}) + x122*cell[23];
cell[24] = -x119*x120*x121*x123*x203*(-x124*(-x213 + x226 - V{4.5}*x39*x233*x233) + V{-1}) + x122*cell[24];
cell[25] = -x119*x120*x121*x123*x203*(-x124*(-x219 + x229 - V{4.5}*x39*x234*x234) + V{-1}) + x122*cell[25];
cell[26] = x119*x120*x121*x123*x203*(x124*(-x158*x211*x211 + x198 + x227) + V{1}) + x122*cell[26];
return { x37, V{1}*x39*(x214 + x216 + x220) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x32 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = cell[12] + cell[25];
auto x1 = x0 + cell[18];
auto x2 = cell[11] + cell[24];
auto x3 = x2 + cell[20];
auto x4 = cell[22] + cell[9];
auto x5 = cell[13] + cell[1];
auto x6 = cell[26] + cell[2] + cell[8];
auto x7 = cell[10] + cell[3];
auto x8 = x1 + x3 + x4 + x5 + x6 + x7 + cell[0] + cell[14] + cell[15] + cell[16] + cell[17] + cell[19] + cell[21] + cell[23] + cell[4] + cell[5] + cell[6] + cell[7] + V{1};
auto x9 = V{1} / (x8);
auto x10 = (V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[19] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[20] + V{0.0277777777777778}*cell[21] + V{0.0277777777777778}*cell[22] + V{0.0277777777777778}*cell[23] + V{0.0277777777777778}*cell[24] + V{0.0277777777777778}*cell[25] + V{0.0277777777777778}*cell[26] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778})/((x31)*(x31));
auto x11 = x32*x32;
auto x12 = V{1}*x9;
auto x13 = -cell[17];
auto x14 = -cell[24];
auto x15 = x13 + x14 + cell[5];
auto x16 = -cell[19];
auto x17 = -cell[25];
auto x18 = x16 + x17 + cell[7];
auto x19 = -cell[23];
auto x20 = x19 - cell[26];
auto x21 = cell[10] + cell[11] + cell[4];
auto x22 = cell[12] + cell[6];
auto x23 = x15 + x18 + x20 + x21 + x22 + x5 - cell[14] - cell[18] - cell[20];
auto x24 = -x12*x23*x23;
auto x25 = V{0.666666666666667}*cell[10];
auto x26 = V{0.666666666666667}*cell[11];
auto x27 = V{0.666666666666667}*cell[12];
auto x28 = V{0.666666666666667}*cell[13];
auto x29 = V{0.666666666666667}*cell[23];
auto x30 = V{0.666666666666667}*cell[24];
auto x33 = V{0.666666666666667}*cell[25];
auto x34 = V{0.666666666666667}*cell[26];
auto x35 = -V{0.333333333333333}*cell[0];
auto x36 = x25 + x26 + x27 + x28 + x29 + x30 + x33 + x34 + x35 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x37 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x38 = x36 + x37 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x39 = x24 + x38;
auto x40 = -cell[12];
auto x41 = -cell[13] - cell[21];
auto x42 = x19 + x41;
auto x43 = x13 + x14 + x21 + x40 + x42 + x6 - cell[15] + cell[18] - cell[22] + cell[25] - cell[5] + cell[9];
auto x44 = -x12*x43*x43;
auto x45 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x46 = x36 + x45 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x47 = x44 + x46;
auto x48 = -cell[11];
auto x49 = x16 + x17 + x22 + x42 + x48 + x7 - cell[16] + cell[20] + cell[22] + cell[24] + cell[26] - cell[7] + cell[8] - cell[9];
auto x50 = -x12*x49*x49;
auto x51 = x25 + x26 + x27 + x28 + x29 + x30 + x33 + x34 + x35 + x37 + x45 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x52 = x50 + x51;
auto x53 = -x43;
auto x54 = -x23;
auto x55 = x54*x9;
auto x56 = -cell[10];
auto x57 = x19 + x56 + cell[13] + cell[26];
auto x58 = x1 + x15 + x48 + x53*x55 + x57 - cell[4];
auto x59 = -x49;
auto x60 = x18 + x3 + x40 + x55*x59 + x57 - cell[6];
auto x61 = x0 + x2 + x20 + x4 + x41 + x53*x59*x9 + x56 - cell[8];
auto x62 = util::sqrt(V{0.5}*(x39*x39) + V{0.5}*(x47*x47) + V{0.5}*(x52*x52) + x58*x58 + x60*x60 + x61*x61);
auto x63 = (V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[19] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[20] + V{0.166666666666667}*cell[21] + V{0.166666666666667}*cell[22] + V{0.166666666666667}*cell[23] + V{0.166666666666667}*cell[24] + V{0.166666666666667}*cell[25] + V{0.166666666666667}*cell[26] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{0.166666666666667})/x31;
auto x64 = -x63 + util::sqrt(x8*(x10 + x11*x62));
auto x65 = -x12*x54*x54 + x38;
auto x66 = -x12*x53*x53 + x46;
auto x67 = -x12*x59*x59 + x51;
auto x68 = -x58;
auto x69 = -x60;
auto x70 = -x61;
return V{7.54247466666667}*x9*(x24 + x44 + x50 - V{1}*cell[0] + V{2}*cell[10] + V{2}*cell[11] + V{2}*cell[12] + V{2}*cell[13] + V{1.11022302462516e-16}*cell[14] + V{1.11022302462516e-16}*cell[15] + V{1.11022302462516e-16}*cell[16] + V{1}*cell[17] + V{1}*cell[18] + V{1}*cell[19] + V{1.11022302462516e-16}*cell[1] + V{1}*cell[20] + V{1}*cell[21] + V{1}*cell[22] + V{2}*cell[23] + V{2}*cell[24] + V{2}*cell[25] + V{2}*cell[26] + V{1.11022302462516e-16}*cell[2] + V{1.11022302462516e-16}*cell[3] + V{1}*cell[4] + V{1}*cell[5] + V{1}*cell[6] + V{1}*cell[7] + V{1}*cell[8] + V{1}*cell[9])*util::sqrt((x64*x64)/(util::pow(x32, 4)*((x8)*(x8))))*(-V{0.166666666666667}*x63 + V{0.166666666666667}*util::sqrt(x8*(x10 + x11*util::sqrt(V{0.5}*(x65*x65) + V{0.5}*(x66*x66) + V{0.5}*(x67*x67) + x68*x68 + x69*x69 + x70*x70))))/x62;
}
 
};
 
 
template <typename... FIELDS>
struct ConStrainSmagorinskyEffectiveOmega<BGK,descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x9 = V{1} / (x12);
auto x10 = x13*x13;
auto x11 = cell[1] + cell[7];
auto x14 = x11 + cell[0] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + V{1};
auto x15 = V{1} / ((x14)*(x14));
auto x16 = -cell[3];
auto x17 = cell[1] - cell[7];
auto x18 = -cell[5];
auto x19 = x18 + cell[3];
auto x20 = cell[2] - cell[6];
auto x21 = x17 + x19 + x20;
auto x22 = -x21;
auto x23 = V{1} / (x14);
auto x24 = -cell[4] + cell[8];
auto x25 = x11 + x16 + x18 + x24;
auto x26 = x23*x25;
auto x27 = x16 + x17 + x22*x26 + cell[5];
auto x28 = V{1}*x23;
auto x29 = x21*x21;
auto x30 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x31 = -x28*x29 + x30 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x32 = x31*x31;
auto x33 = x25*x25;
auto x34 = -x28*x33 + x30 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x35 = x34*x34;
auto x36 = V{0.5}*x32 + V{0.5}*x35;
auto x37 = -x9*(V{0.198201185833787}*cell[0] + V{0.198201185833787}*cell[1] + V{0.198201185833787}*cell[2] + V{0.198201185833787}*cell[3] + V{0.198201185833787}*cell[4] + V{0.198201185833787}*cell[5] + V{0.198201185833787}*cell[6] + V{0.198201185833787}*cell[7] + V{0.198201185833787}*cell[8] + V{0.198201185833787}) + util::sqrt(x14*(V{1.4142135623731}*x10*util::sqrt(x36 + x27*x27) + (V{0.0392837100659193}*cell[0] + V{0.0392837100659193}*cell[1] + V{0.0392837100659193}*cell[2] + V{0.0392837100659193}*cell[3] + V{0.0392837100659193}*cell[4] + V{0.0392837100659193}*cell[5] + V{0.0392837100659193}*cell[6] + V{0.0392837100659193}*cell[7] + V{0.0392837100659193}*cell[8] + V{0.0392837100659193})/((x12)*(x12))));
auto x38 = -x19 - x21*x26 + cell[1] - cell[7];
auto x39 = x38*x38;
auto x40 = V{1} / (V{3.56762134500816}*x10*util::sqrt(x15*(x37*x37)*V{1} / (x32 + x35 + V{2}*x39)*(x36 + x39)/util::pow(x13, 4)) + V{1}*x9);
auto x41 = V{1.5}*x15;
auto x42 = x33*x41;
auto x43 = x41*(x22*x22) + V{-1};
auto x44 = x42 + x43;
auto x45 = V{1} - x40;
auto x46 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778};
auto x47 = V{4.5}*x15;
auto x48 = x20 + x24 + V{2}*cell[1] - V{2}*cell[5];
auto x49 = x47*(x48*x48);
auto x50 = V{3}*cell[3];
auto x51 = V{3}*cell[7];
auto x52 = V{3}*cell[1] - V{3}*cell[5];
auto x53 = x50 - x51 + x52 + V{3}*cell[2] - V{3}*cell[6];
auto x54 = x23*x53;
auto x55 = -x42 + x54 + V{1};
auto x56 = -x50 + x51 + x52 - V{3}*cell[4] + V{3}*cell[8];
auto x57 = x23*x56;
auto x58 = x29*x41;
auto x59 = x57 - x58;
auto x60 = V{0.111111111111111}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7] + V{0.111111111111111}*cell[8] + V{0.111111111111111};
auto x61 = V{3}*x15;
auto x62 = x20 + V{2}*cell[3] + cell[4] - V{2}*cell[7] - cell[8];
auto x63 = -x62;
auto x64 = x33*x61;
auto x65 = x42 + x54 + V{-1};
auto x66 = x58 + x65;
auto x0 = -x40*(x44*(V{0.444444444444444}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}) + V{0.444444444444444}) + V{1}*x45*cell[0];
auto x1 = x40*(x46*(x49 + x55 + x59) + V{-0.0277777777777778}) + V{1}*x45*cell[1];
auto x2 = x40*(x60*(x29*x61 + x55) + V{-0.111111111111111}) + V{1}*x45*cell[2];
auto x3 = -x40*(x46*(-x23*x53 + x44 - x47*x63*x63 + x57) + V{0.0277777777777778}) + V{1}*x45*cell[3];
auto x4 = -x40*(x60*(x43 + x57 - x64) + V{0.111111111111111}) + V{1}*x45*cell[4];
auto x5 = -x40*(x46*(-x49 + x57 + x66) + V{0.0277777777777778}) + V{1}*x45*cell[5];
auto x6 = x40*(x60*(V{3}*x15*x29 - x65) + V{-0.111111111111111}) + V{1}*x45*cell[6];
auto x7 = x40*(-x46*(-V{4.5}*x15*x62*x62 - x23*x56 + x66) + V{-0.0277777777777778}) + V{1}*x45*cell[7];
auto x8 = x40*(x60*(x59 + x64 + V{1}) + V{-0.111111111111111}) + V{1}*x45*cell[8];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { x14, V{1}*x15*(x29 + x33) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x13 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x12 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = V{1} / (x12);
auto x1 = x13*x13;
auto x2 = cell[1] + cell[7] + cell[8];
auto x3 = x2 + cell[0] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + V{1};
auto x4 = -cell[3];
auto x5 = cell[1] - cell[7];
auto x6 = -cell[5];
auto x7 = x6 + cell[3];
auto x8 = x5 + x7 + cell[2] - cell[6];
auto x9 = V{1} / (x3);
auto x10 = x2 + x4 + x6 - cell[4];
auto x11 = x10*x9;
auto x14 = -x11*x8 + x4 + x5 + cell[5];
auto x15 = V{1}*x9;
auto x16 = -V{0.333333333333333}*cell[0] + V{0.666666666666667}*cell[1] + V{0.666666666666667}*cell[3] + V{0.666666666666667}*cell[5] + V{0.666666666666667}*cell[7];
auto x17 = -x15*x8*x8 + x16 + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[4] + V{0.666666666666667}*cell[6] - V{0.333333333333333}*cell[8];
auto x18 = x17*x17;
auto x19 = -x15*x10*x10 + x16 - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[4] - V{0.333333333333333}*cell[6] + V{0.666666666666667}*cell[8];
auto x20 = x19*x19;
auto x21 = V{0.5}*x18 + V{0.5}*x20;
auto x22 = -x0*(V{0.198201185833787}*cell[0] + V{0.198201185833787}*cell[1] + V{0.198201185833787}*cell[2] + V{0.198201185833787}*cell[3] + V{0.198201185833787}*cell[4] + V{0.198201185833787}*cell[5] + V{0.198201185833787}*cell[6] + V{0.198201185833787}*cell[7] + V{0.198201185833787}*cell[8] + V{0.198201185833787}) + util::sqrt(x3*(V{1.4142135623731}*x1*util::sqrt(x21 + x14*x14) + (V{0.0392837100659193}*cell[0] + V{0.0392837100659193}*cell[1] + V{0.0392837100659193}*cell[2] + V{0.0392837100659193}*cell[3] + V{0.0392837100659193}*cell[4] + V{0.0392837100659193}*cell[5] + V{0.0392837100659193}*cell[6] + V{0.0392837100659193}*cell[7] + V{0.0392837100659193}*cell[8] + V{0.0392837100659193})/((x12)*(x12))));
auto x23 = -x11*x8 - x7 + cell[1] - cell[7];
auto x24 = x23*x23;
return V{1} / (V{1}*x0 + V{3.56762134500816}*x1*util::sqrt((x22*x22)*V{1} / (x18 + x20 + V{2}*x24)*(x21 + x24)/(util::pow(x13, 4)*((x3)*(x3)))));
}
 
};
 
template <typename... FIELDS>
struct ConStrainSmagorinskyEffectiveOmega<BGK,descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x24 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x19 = V{1} / (x23);
auto x20 = x24*x24;
auto x21 = cell[15] + cell[17];
auto x22 = x21 + cell[12];
auto x25 = cell[11] + cell[18];
auto x26 = cell[10] + cell[14] + cell[16];
auto x27 = cell[2] + cell[8] + cell[9];
auto x28 = cell[13] + cell[3];
auto x29 = x22 + x25 + x26 + x27 + x28 + cell[0] + cell[1] + cell[4] + cell[5] + cell[6] + cell[7] + V{1};
auto x30 = V{1} / ((x29)*(x29));
auto x31 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x32 = V{0.333333333333333}*cell[4];
auto x33 = V{0.333333333333333}*cell[5];
auto x34 = V{0.333333333333333}*cell[13];
auto x35 = V{0.333333333333333}*cell[14];
auto x36 = V{1} / (x29);
auto x37 = V{1}*x36;
auto x38 = -cell[3];
auto x39 = -cell[18];
auto x40 = -cell[8];
auto x41 = x40 + cell[9];
auto x42 = x38 + x39 + x41;
auto x43 = -cell[6];
auto x44 = x43 + cell[7];
auto x45 = x44 - cell[16];
auto x46 = x22 + x42 + x45;
auto x47 = x46*x46;
auto x48 = V{0.333333333333333}*cell[0];
auto x49 = V{0.333333333333333}*cell[1];
auto x50 = V{0.333333333333333}*cell[10];
auto x51 = x48 + x49 + x50 - V{0.666666666666667}*cell[17] - V{0.666666666666667}*cell[18] - V{0.666666666666667}*cell[8] - V{0.666666666666667}*cell[9];
auto x52 = V{0.333333333333333}*cell[2];
auto x53 = V{0.333333333333333}*cell[11];
auto x54 = x52 + x53 - V{0.666666666666667}*cell[15] - V{0.666666666666667}*cell[16] - V{0.666666666666667}*cell[6] - V{0.666666666666667}*cell[7];
auto x55 = x32 + x33 + x34 + x35 + x37*x47 + x51 + x54 - V{0.666666666666667}*cell[12] - V{0.666666666666667}*cell[3];
auto x56 = V{0.333333333333333}*cell[6];
auto x57 = V{0.333333333333333}*cell[7];
auto x58 = V{0.333333333333333}*cell[15];
auto x59 = V{0.333333333333333}*cell[16];
auto x60 = cell[13] + cell[17];
auto x61 = -cell[2];
auto x62 = -cell[9];
auto x63 = x25 + x40 + x61 + x62;
auto x64 = -cell[4];
auto x65 = x64 + cell[5];
auto x66 = x65 - cell[14];
auto x67 = x60 + x63 + x66;
auto x68 = x67*x67;
auto x69 = V{0.333333333333333}*cell[3];
auto x70 = V{0.333333333333333}*cell[12];
auto x71 = x69 + x70 - V{0.666666666666667}*cell[13] - V{0.666666666666667}*cell[14] - V{0.666666666666667}*cell[4] - V{0.666666666666667}*cell[5];
auto x72 = x37*x68 + x51 + x56 + x57 + x58 + x59 + x71 - V{0.666666666666667}*cell[11] - V{0.666666666666667}*cell[2];
auto x73 = V{0.333333333333333}*cell[8];
auto x74 = V{0.333333333333333}*cell[9];
auto x75 = V{0.333333333333333}*cell[17];
auto x76 = V{0.333333333333333}*cell[18];
auto x77 = cell[13] + cell[15];
auto x78 = -cell[1];
auto x79 = -cell[7];
auto x80 = x43 + x78 + x79;
auto x81 = x64 - cell[5];
auto x82 = x26 + x77 + x80 + x81;
auto x83 = x82*x82;
auto x84 = x37*x83 + x48 + x54 + x71 + x73 + x74 + x75 + x76 - V{0.666666666666667}*cell[10] - V{0.666666666666667}*cell[1];
auto x85 = x36*x82;
auto x86 = x65 + x67*x85 - cell[13] + cell[14];
auto x87 = -cell[15] + cell[16];
auto x88 = x44 + x46*x85 + x87;
auto x89 = -cell[17];
auto x90 = x89 + cell[18];
auto x91 = x36*x46*x67 + x41 + x90;
auto x92 = -x19*(V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{0.166666666666667}) + util::sqrt(x29*(x20*util::sqrt(V{0.5}*(x55*x55) + V{0.5}*(x72*x72) + V{0.5}*(x84*x84) + x86*x86 + x88*x88 + x91*x91) + x31/((x23)*(x23))));
auto x93 = V{1} / (V{1}*x19 + V{3}*x20*util::sqrt(x30*(x92*x92)/util::pow(x24, 4)));
auto x94 = V{1.5}*x30;
auto x95 = x83*x94;
auto x96 = x68*x94;
auto x97 = x47*x94;
auto x98 = x96 + x97 + V{-1};
auto x99 = x95 + x98;
auto x100 = V{1} - x93;
auto x101 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[10] + V{0.0555555555555556}*cell[11] + V{0.0555555555555556}*cell[12] + V{0.0555555555555556}*cell[13] + V{0.0555555555555556}*cell[14] + V{0.0555555555555556}*cell[15] + V{0.0555555555555556}*cell[16] + V{0.0555555555555556}*cell[17] + V{0.0555555555555556}*cell[18] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556}*cell[9] + V{0.0555555555555556};
auto x102 = V{3}*cell[14];
auto x103 = V{3}*cell[16];
auto x104 = V{3}*cell[5];
auto x105 = V{3}*cell[7];
auto x106 = V{3}*cell[13] - V{3}*cell[4];
auto x107 = V{3}*cell[15] - V{3}*cell[6];
auto x108 = x36*(x102 + x103 - x104 - x105 + x106 + x107 + V{3}*cell[10] - V{3}*cell[1]);
auto x109 = V{3}*x30;
auto x110 = x109*x83;
auto x111 = V{3}*cell[18];
auto x112 = V{3}*cell[9];
auto x113 = V{3}*cell[17] - V{3}*cell[8];
auto x114 = x36*(-x102 + x104 + x106 + x111 - x112 + x113 + V{3}*cell[11] - V{3}*cell[2]);
auto x115 = x109*x68;
auto x116 = x95 + V{-1};
auto x117 = x36*(-x103 + x105 + x107 - x111 + x112 + x113 + V{3}*cell[12] - V{3}*cell[3]);
auto x118 = x109*x47;
auto x119 = V{4.5}*x30;
auto x120 = x80 + cell[10] + cell[16];
auto x121 = x120 + x21 + x63 + V{2}*cell[13] - V{2}*cell[4];
auto x122 = x119*(x121*x121);
auto x123 = x108 + x99;
auto x124 = -x114;
auto x125 = x120 + x27 + x39 + x89 - cell[11] + V{2}*cell[14] + cell[15] - V{2}*cell[5];
auto x126 = -x125;
auto x127 = x78 + x81 + cell[10] + cell[14];
auto x128 = x127 + x42 + x60 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x129 = x119*(x128*x128);
auto x130 = -x117;
auto x131 = x28 - cell[12];
auto x132 = x127 + x131 + x62 + x90 + V{2}*cell[16] - V{2}*cell[7] + cell[8];
auto x133 = -x132;
auto x134 = x61 + x66 + cell[11];
auto x135 = x134 + x38 + x45 + x77 + cell[12] + V{2}*cell[17] - V{2}*cell[8];
auto x136 = x119*(x135*x135);
auto x137 = x114 + x99;
auto x138 = x131 + x134 + x79 + x87 + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x139 = -x138;
auto x140 = -x96;
auto x141 = V{1} - x97;
auto x142 = x140 + x141;
auto x143 = x108 + x142;
auto x144 = -x95;
auto x145 = x114 + x144;
auto x146 = x117 + x144;
auto x147 = -x108;
auto x148 = x117 + x99;
cell[0] = V{1}*x100*cell[0] - x93*(x99*(x32 + x33 + x34 + x35 + x48 + x49 + x50 + x52 + x53 + x56 + x57 + x58 + x59 + x69 + x70 + x73 + x74 + x75 + x76 + V{0.333333333333333}) + V{0.333333333333333});
cell[1] = V{1}*x100*cell[1] - x93*(x101*(x108 - x110 + x98) + V{0.0555555555555556});
cell[2] = V{1}*x100*cell[2] - x93*(x101*(x114 - x115 + x116 + x97) + V{0.0555555555555556});
cell[3] = V{1}*x100*cell[3] - x93*(x101*(x116 + x117 - x118 + x96) + V{0.0555555555555556});
cell[4] = V{1}*x100*cell[4] - x93*(x31*(x114 - x122 + x123) + V{0.0277777777777778});
cell[5] = V{1}*x100*cell[5] - x93*(x31*(-x119*x126*x126 + x123 + x124) + V{0.0277777777777778});
cell[6] = V{1}*x100*cell[6] - x93*(x31*(x117 + x123 - x129) + V{0.0277777777777778});
cell[7] = V{1}*x100*cell[7] - x93*(x31*(-x119*x133*x133 + x123 + x130) + V{0.0277777777777778});
cell[8] = V{1}*x100*cell[8] - x93*(x31*(x117 - x136 + x137) + V{0.0277777777777778});
cell[9] = V{1}*x100*cell[9] - x93*(x31*(-x119*x139*x139 + x130 + x137) + V{0.0277777777777778});
cell[10] = V{1}*x100*cell[10] + x93*(x101*(x110 + x143) + V{-0.0555555555555556});
cell[11] = V{1}*x100*cell[11] + x93*(x101*(x115 + x141 + x145) + V{-0.0555555555555556});
cell[12] = V{1}*x100*cell[12] + x93*(x101*(x118 + x140 + x146 + V{1}) + V{-0.0555555555555556});
cell[13] = V{1}*x100*cell[13] + x93*(x31*(x122 + x143 + x145) + V{-0.0277777777777778});
cell[14] = V{1}*x100*cell[14] - x93*(x31*(-x119*x125*x125 + x137 + x147) + V{0.0277777777777778});
cell[15] = V{1}*x100*cell[15] + x93*(x31*(x129 + x143 + x146) + V{-0.0277777777777778});
cell[16] = V{1}*x100*cell[16] - x93*(x31*(-x119*x132*x132 + x147 + x148) + V{0.0277777777777778});
cell[17] = V{1}*x100*cell[17] + x93*(x31*(x117 + x136 + x142 + x145) + V{-0.0277777777777778});
cell[18] = V{1}*x100*cell[18] - x93*(x31*(-x119*x138*x138 + x124 + x148) + V{0.0277777777777778});
return { x29, V{1}*x30*(x47 + x68 + x83) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x23 = parameters.template get<olb::descriptors::OMEGA>();
auto x24 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x0 = V{1} / (x23);
auto x1 = x24*x24;
auto x2 = cell[12] + cell[15] + cell[17];
auto x3 = cell[11] + cell[13] + cell[18];
auto x4 = cell[10] + cell[14] + cell[16];
auto x5 = x2 + x3 + x4 + cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1};
auto x6 = V{1} / (x5);
auto x7 = V{1}*x6;
auto x8 = -cell[6];
auto x9 = x8 + cell[7];
auto x10 = -cell[8];
auto x11 = x10 + cell[9];
auto x12 = x11 + x2 + x9 - cell[16] - cell[18] - cell[3];
auto x13 = V{0.333333333333333}*cell[0];
auto x14 = x13 + V{0.333333333333333}*cell[10] - V{0.666666666666667}*cell[17] - V{0.666666666666667}*cell[18] + V{0.333333333333333}*cell[1] - V{0.666666666666667}*cell[8] - V{0.666666666666667}*cell[9];
auto x15 = V{0.333333333333333}*cell[11] - V{0.666666666666667}*cell[15] - V{0.666666666666667}*cell[16] + V{0.333333333333333}*cell[2] - V{0.666666666666667}*cell[6] - V{0.666666666666667}*cell[7];
auto x16 = x14 + x15 + x7*(x12*x12) - V{0.666666666666667}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] - V{0.666666666666667}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5];
auto x17 = -cell[4];
auto x18 = x17 + cell[5];
auto x19 = x10 + x18 + x3 - cell[14] + cell[17] - cell[2] - cell[9];
auto x20 = V{0.333333333333333}*cell[12] - V{0.666666666666667}*cell[13] - V{0.666666666666667}*cell[14] + V{0.333333333333333}*cell[3] - V{0.666666666666667}*cell[4] - V{0.666666666666667}*cell[5];
auto x21 = x14 + x20 + x7*(x19*x19) - V{0.666666666666667}*cell[11] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] - V{0.666666666666667}*cell[2] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7];
auto x22 = x17 + x4 + x8 + cell[13] + cell[15] - cell[1] - cell[5] - cell[7];
auto x25 = x13 + x15 + x20 + x7*(x22*x22) - V{0.666666666666667}*cell[10] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] - V{0.666666666666667}*cell[1] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9];
auto x26 = x22*x6;
auto x27 = x18 + x19*x26 - cell[13] + cell[14];
auto x28 = x12*x26 + x9 - cell[15] + cell[16];
auto x29 = x11 + x12*x19*x6 - cell[17] + cell[18];
auto x30 = -x0*(V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{0.166666666666667}) + util::sqrt(x5*(x1*util::sqrt(V{0.5}*(x16*x16) + V{0.5}*(x21*x21) + V{0.5}*(x25*x25) + x27*x27 + x28*x28 + x29*x29) + (V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778})/((x23)*(x23))));
return V{1} / (V{1}*x0 + V{3}*x1*util::sqrt((x30*x30)/(util::pow(x24, 4)*((x5)*(x5)))));
}
 
};
 
template <typename... FIELDS>
struct ConStrainSmagorinskyEffectiveOmega<BGK,descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x32 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x27 = V{1} / (x31);
auto x28 = x32*x32;
auto x29 = cell[10] + cell[6];
auto x30 = x29 + cell[13];
auto x33 = cell[12] + cell[26];
auto x34 = cell[15] + cell[21];
auto x35 = cell[19] + cell[7];
auto x36 = cell[24] + cell[25];
auto x37 = x36 + cell[14];
auto x38 = x30 + x33 + x34 + x35 + x37 + cell[0] + cell[11] + cell[16] + cell[17] + cell[18] + cell[1] + cell[20] + cell[22] + cell[23] + cell[2] + cell[3] + cell[4] + cell[5] + cell[8] + cell[9] + V{1};
auto x39 = V{1} / ((x38)*(x38));
auto x40 = V{1} / (x38);
auto x41 = V{1}*x40;
auto x42 = -cell[24];
auto x43 = -cell[19];
auto x44 = x43 + cell[7];
auto x45 = -cell[25];
auto x46 = x45 + cell[11];
auto x47 = x44 + x46;
auto x48 = -cell[23];
auto x49 = -cell[26];
auto x50 = x48 + x49 + cell[12];
auto x51 = -cell[20];
auto x52 = x51 + cell[4];
auto x53 = -cell[17];
auto x54 = x53 + cell[5];
auto x55 = -cell[14] + cell[1];
auto x56 = x54 + x55 - cell[18];
auto x57 = x30 + x42 + x47 + x50 + x52 + x56;
auto x58 = x57*x57;
auto x59 = V{0.666666666666667}*cell[10];
auto x60 = V{0.666666666666667}*cell[11];
auto x61 = V{0.666666666666667}*cell[12];
auto x62 = V{0.666666666666667}*cell[13];
auto x63 = V{0.666666666666667}*cell[23];
auto x64 = V{0.666666666666667}*cell[24];
auto x65 = V{0.666666666666667}*cell[25];
auto x66 = V{0.666666666666667}*cell[26];
auto x67 = -V{0.333333333333333}*cell[0];
auto x68 = x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 + x67 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x69 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x70 = -x41*x58 + x68 + x69 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x71 = -cell[12];
auto x72 = x71 + cell[26];
auto x73 = -cell[13];
auto x74 = -cell[21];
auto x75 = x74 + cell[9];
auto x76 = x73 + x75 + cell[11];
auto x77 = x48 + cell[8];
auto x78 = -cell[22];
auto x79 = x78 + cell[4];
auto x80 = -cell[15] + cell[2];
auto x81 = x80 + cell[10];
auto x82 = x53 + cell[18] - cell[5];
auto x83 = x42 + x72 + x76 + x77 + x79 + x81 + x82 + cell[25];
auto x84 = x83*x83;
auto x85 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x86 = -x41*x84 + x68 + x85 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x87 = -cell[11];
auto x88 = -cell[16];
auto x89 = x73 + x88 + cell[3];
auto x90 = -cell[9];
auto x91 = x74 + x90 + cell[22];
auto x92 = x43 + cell[20] - cell[7];
auto x93 = x29 + x33 + x45 + x77 + x87 + x89 + x91 + x92 + cell[24];
auto x94 = x93*x93;
auto x95 = -x41*x94 + x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 + x67 + x69 + x85 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x96 = -cell[10];
auto x97 = -x83;
auto x98 = -x57;
auto x99 = x40*x98;
auto x100 = x42 + cell[12] + cell[26];
auto x101 = x48 + cell[13] + cell[25];
auto x102 = x100 + x101 + x54 + x87 + x96 + x97*x99 + cell[18] - cell[4];
auto x103 = -cell[6];
auto x104 = -x93;
auto x105 = x48 + cell[13] + cell[24];
auto x106 = x103 + x104*x99 + x105 + x47 + x72 + x96 + cell[20];
auto x107 = -cell[8];
auto x108 = x107 + cell[22];
auto x109 = x104*x40*x97 + x108 + x36 + x50 + x76 + x96;
auto x110 = -x27*(V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[19] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[20] + V{0.166666666666667}*cell[21] + V{0.166666666666667}*cell[22] + V{0.166666666666667}*cell[23] + V{0.166666666666667}*cell[24] + V{0.166666666666667}*cell[25] + V{0.166666666666667}*cell[26] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{0.166666666666667}) + util::sqrt(x38*(x28*util::sqrt(x102*x102 + x106*x106 + x109*x109 + V{0.5}*(x70*x70) + V{0.5}*(x86*x86) + V{0.5}*(x95*x95)) + (V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[19] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[20] + V{0.0277777777777778}*cell[21] + V{0.0277777777777778}*cell[22] + V{0.0277777777777778}*cell[23] + V{0.0277777777777778}*cell[24] + V{0.0277777777777778}*cell[25] + V{0.0277777777777778}*cell[26] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778})/((x31)*(x31))));
auto x111 = V{1} / (V{1}*x27 + V{3}*x28*util::sqrt(x39*(x110*x110)/util::pow(x32, 4)));
auto x112 = V{1.5}*x39;
auto x113 = x98*x98;
auto x114 = x112*x113;
auto x115 = x97*x97;
auto x116 = x112*x115;
auto x117 = x104*x104;
auto x118 = x112*x117;
auto x119 = x116 + x118 + V{-1};
auto x120 = x114 + x119;
auto x121 = V{1} - x111;
auto x122 = V{0.0740740740740741}*cell[0] + V{0.0740740740740741}*cell[10] + V{0.0740740740740741}*cell[11] + V{0.0740740740740741}*cell[12] + V{0.0740740740740741}*cell[13] + V{0.0740740740740741}*cell[14] + V{0.0740740740740741}*cell[15] + V{0.0740740740740741}*cell[16] + V{0.0740740740740741}*cell[17] + V{0.0740740740740741}*cell[18] + V{0.0740740740740741}*cell[19] + V{0.0740740740740741}*cell[1] + V{0.0740740740740741}*cell[20] + V{0.0740740740740741}*cell[21] + V{0.0740740740740741}*cell[22] + V{0.0740740740740741}*cell[23] + V{0.0740740740740741}*cell[24] + V{0.0740740740740741}*cell[25] + V{0.0740740740740741}*cell[26] + V{0.0740740740740741}*cell[2] + V{0.0740740740740741}*cell[3] + V{0.0740740740740741}*cell[4] + V{0.0740740740740741}*cell[5] + V{0.0740740740740741}*cell[6] + V{0.0740740740740741}*cell[7] + V{0.0740740740740741}*cell[8] + V{0.0740740740740741}*cell[9] + V{0.0740740740740741};
auto x123 = V{3}*cell[5];
auto x124 = V{3}*cell[7];
auto x125 = V{3}*cell[13];
auto x126 = V{3}*cell[18];
auto x127 = V{3}*cell[20];
auto x128 = V{3}*cell[26];
auto x129 = V{3}*cell[10];
auto x130 = V{3}*cell[11];
auto x131 = -V{3}*cell[23];
auto x132 = V{3}*cell[24];
auto x133 = x129 + x130 + x131 - x132 - V{3}*cell[17] + V{3}*cell[4];
auto x134 = V{3}*cell[12];
auto x135 = V{3}*cell[25];
auto x136 = x134 - x135 - V{3}*cell[19] + V{3}*cell[6];
auto x137 = x123 + x124 + x125 - x126 - x127 - x128 + x133 + x136 - V{3}*cell[14] + V{3}*cell[1];
auto x138 = -x137*x40;
auto x139 = V{3}*x39;
auto x140 = V{3}*cell[9];
auto x141 = V{3}*cell[22];
auto x142 = -x125 + x128 - V{3}*cell[21] + V{3}*cell[8];
auto x143 = -x123 + x126 + x133 - x134 + x135 + x140 - x141 + x142 - V{3}*cell[15] + V{3}*cell[2];
auto x144 = -x143*x40;
auto x145 = x114 + V{-1};
auto x146 = -x124 + x127 + x129 - x130 + x131 + x132 + x136 - x140 + x141 + x142 - V{3}*cell[16] + V{3}*cell[3];
auto x147 = -x146*x40;
auto x148 = V{0.0185185185185185}*cell[0] + V{0.0185185185185185}*cell[10] + V{0.0185185185185185}*cell[11] + V{0.0185185185185185}*cell[12] + V{0.0185185185185185}*cell[13] + V{0.0185185185185185}*cell[14] + V{0.0185185185185185}*cell[15] + V{0.0185185185185185}*cell[16] + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[1] + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[23] + V{0.0185185185185185}*cell[24] + V{0.0185185185185185}*cell[25] + V{0.0185185185185185}*cell[26] + V{0.0185185185185185}*cell[2] + V{0.0185185185185185}*cell[3] + V{0.0185185185185185}*cell[4] + V{0.0185185185185185}*cell[5] + V{0.0185185185185185}*cell[6] + V{0.0185185185185185}*cell[7] + V{0.0185185185185185}*cell[8] + V{0.0185185185185185}*cell[9] + V{0.0185185185185185};
auto x149 = V{4.5}*x39;
auto x150 = -V{2}*cell[23];
auto x151 = V{2}*cell[10];
auto x152 = x150 + x151 + cell[8];
auto x153 = V{2}*cell[11] - V{2}*cell[24];
auto x154 = x153 + x80;
auto x155 = x55 - V{2}*cell[17] + V{2}*cell[4];
auto x156 = x44 + x51 + cell[6];
auto x157 = x152 + x154 + x155 + x156 + x75 + x78;
auto x158 = -x157;
auto x159 = x120 + x138;
auto x160 = x144 + x159;
auto x161 = V{2}*cell[25];
auto x162 = V{2}*cell[12];
auto x163 = -x161 + x162;
auto x164 = V{2}*cell[26];
auto x165 = V{2}*cell[13];
auto x166 = -x164 + x165;
auto x167 = V{2}*cell[18];
auto x168 = V{2}*cell[5];
auto x169 = -x167 + x168 + x55 - cell[2];
auto x170 = x108 + x156 + x163 + x166 + x169 + x34 + x90;
auto x171 = -x144;
auto x172 = x159 + x171;
auto x173 = -V{2}*cell[19] + V{2}*cell[6];
auto x174 = x88 + cell[3];
auto x175 = x174 + cell[4];
auto x176 = x152 + x163 + x173 + x175 + x56 + x91;
auto x177 = -x176;
auto x178 = -x147;
auto x179 = V{2}*cell[20];
auto x180 = V{2}*cell[7];
auto x181 = cell[16] - cell[3];
auto x182 = -x179 + x180 + x181;
auto x183 = x107 + x153 + x166 + x182 + x56 + x79 + cell[21] + cell[9];
auto x184 = -V{2}*cell[21] + V{2}*cell[8];
auto x185 = x184 + x80;
auto x186 = x150 + x151 + x164 - x165 + x175 + x185 + x82 + x92 + cell[6];
auto x187 = -x186;
auto x188 = x120 + x144;
auto x189 = x147 + x188;
auto x190 = V{2}*cell[22];
auto x191 = V{2}*cell[9];
auto x192 = -x190 + x191;
auto x193 = x103 + x154 + x161 - x162 + x181 + x192 + x35 + x52 + x82;
auto x194 = V{0.00462962962962963}*cell[0] + V{0.00462962962962963}*cell[10] + V{0.00462962962962963}*cell[11] + V{0.00462962962962963}*cell[12] + V{0.00462962962962963}*cell[13] + V{0.00462962962962963}*cell[14] + V{0.00462962962962963}*cell[15] + V{0.00462962962962963}*cell[16] + V{0.00462962962962963}*cell[17] + V{0.00462962962962963}*cell[18] + V{0.00462962962962963}*cell[19] + V{0.00462962962962963}*cell[1] + V{0.00462962962962963}*cell[20] + V{0.00462962962962963}*cell[21] + V{0.00462962962962963}*cell[22] + V{0.00462962962962963}*cell[23] + V{0.00462962962962963}*cell[24] + V{0.00462962962962963}*cell[25] + V{0.00462962962962963}*cell[26] + V{0.00462962962962963}*cell[2] + V{0.00462962962962963}*cell[3] + V{0.00462962962962963}*cell[4] + V{0.00462962962962963}*cell[5] + V{0.00462962962962963}*cell[6] + V{0.00462962962962963}*cell[7] + V{0.00462962962962963}*cell[8] + V{0.00462962962962963}*cell[9] + V{0.00462962962962963};
auto x195 = x100 + x155 + x173 + x185 + x46 + x89 + V{3}*cell[10] - V{3}*cell[23];
auto x196 = -x195;
auto x197 = x71 + x81;
auto x198 = x101 + x155 + x182 + x192 + x197 + x49 + V{3}*cell[11] - V{3}*cell[24];
auto x199 = x174 + x87;
auto x200 = x105 + x169 + x173 + x190 - x191 + x199 + x49 + cell[10] + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x201 = x137*x40;
auto x202 = x167 - x168 + x179 - x180 + x184 + x197 + x199 + x37 + x48 - V{3}*cell[13] - cell[1] + V{3}*cell[26];
auto x203 = -x202;
auto x204 = x146*x40;
auto x205 = x112*x84;
auto x206 = x112*x94 + V{-1};
auto x207 = x205 + x206;
auto x208 = x143*x40;
auto x209 = x112*x58;
auto x210 = x208 + x209;
auto x211 = x204 + x207 + x210;
auto x212 = x201 + x207;
auto x213 = x204 + x209;
auto x214 = x210 + x212;
auto x215 = -x138;
auto x216 = -x170;
auto x217 = x212 + x213;
auto x218 = -x183;
auto x219 = x120 + x147;
auto x220 = -x193;
auto x221 = -x198;
auto x222 = -x200;
auto x0 = -x111*(x120*(V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296}) + V{0.296296296296296}) + V{1}*x121*cell[0];
auto x1 = -x111*(x122*(-x113*x139 + x119 + x138) + V{0.0740740740740741}) + V{1}*x121*cell[1];
auto x2 = -x111*(x122*(-x115*x139 + x118 + x144 + x145) + V{0.0740740740740741}) + V{1}*x121*cell[2];
auto x3 = -x111*(x122*(x116 - x117*x139 + x145 + x147) + V{0.0740740740740741}) + V{1}*x121*cell[3];
auto x4 = -x111*(x148*(-x149*x158*x158 + x160) + V{0.0185185185185185}) + V{1}*x121*cell[4];
auto x5 = -x111*(x148*(-x149*x170*x170 + x172) + V{0.0185185185185185}) + V{1}*x121*cell[5];
auto x6 = -x111*(x148*(x147 - x149*x177*x177 + x159) + V{0.0185185185185185}) + V{1}*x121*cell[6];
auto x7 = -x111*(x148*(-x149*x183*x183 + x159 + x178) + V{0.0185185185185185}) + V{1}*x121*cell[7];
auto x8 = -x111*(x148*(-x149*x187*x187 + x189) + V{0.0185185185185185}) + V{1}*x121*cell[8];
auto x9 = -x111*(x148*(-x149*x193*x193 + x178 + x188) + V{0.0185185185185185}) + V{1}*x121*cell[9];
auto x10 = -x111*(x194*(x147 - x149*x196*x196 + x160) + V{0.00462962962962963}) + V{1}*x121*cell[10];
auto x11 = -x111*(x194*(-x149*x198*x198 + x160 + x178) + V{0.00462962962962963}) + V{1}*x121*cell[11];
auto x12 = -x111*(x194*(x147 - x149*x200*x200 + x172) + V{0.00462962962962963}) + V{1}*x121*cell[12];
auto x13 = -x111*(x194*(-x149*x203*x203 - x201 + x211) + V{0.00462962962962963}) + V{1}*x121*cell[13];
auto x14 = -x111*(x122*(-x139*x58 + x212) + V{0.0740740740740741}) + V{1}*x121*cell[14];
auto x15 = -x111*(x122*(-x139*x84 + x206 + x210) + V{0.0740740740740741}) + V{1}*x121*cell[15];
auto x16 = -x111*(x122*(-x139*x94 + x205 + x213 + V{-1}) + V{0.0740740740740741}) + V{1}*x121*cell[16];
auto x17 = -x111*(x148*(-x149*x157*x157 + x214) + V{0.0185185185185185}) + V{1}*x121*cell[17];
auto x18 = -x111*(x148*(-x149*x216*x216 + x188 + x215) + V{0.0185185185185185}) + V{1}*x121*cell[18];
auto x19 = -x111*(x148*(-x149*x176*x176 + x217) + V{0.0185185185185185}) + V{1}*x121*cell[19];
auto x20 = -x111*(x148*(-x149*x218*x218 + x215 + x219) + V{0.0185185185185185}) + V{1}*x121*cell[20];
auto x21 = -x111*(x148*(-x149*x186*x186 + x211) + V{0.0185185185185185}) + V{1}*x121*cell[21];
auto x22 = -x111*(x148*(-x149*x220*x220 + x171 + x219) + V{0.0185185185185185}) + V{1}*x121*cell[22];
auto x23 = -x111*(x194*(-x149*x195*x195 + x204 + x214) + V{0.00462962962962963}) + V{1}*x121*cell[23];
auto x24 = -x111*(x194*(-x149*x221*x221 - x204 + x214) + V{0.00462962962962963}) + V{1}*x121*cell[24];
auto x25 = -x111*(x194*(-x149*x222*x222 - x208 + x217) + V{0.00462962962962963}) + V{1}*x121*cell[25];
auto x26 = -x111*(x194*(-x149*x202*x202 + x189 + x215) + V{0.00462962962962963}) + V{1}*x121*cell[26];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { x38, V{1}*x39*(x58 + x84 + x94) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x32 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x31 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = V{1} / (x31);
auto x1 = x32*x32;
auto x2 = cell[12] + cell[25];
auto x3 = x2 + cell[18];
auto x4 = cell[11] + cell[24];
auto x5 = x4 + cell[20];
auto x6 = cell[22] + cell[9];
auto x7 = cell[13] + cell[1];
auto x8 = cell[26] + cell[2] + cell[8];
auto x9 = cell[10] + cell[3];
auto x10 = x3 + x5 + x6 + x7 + x8 + x9 + cell[0] + cell[14] + cell[15] + cell[16] + cell[17] + cell[19] + cell[21] + cell[23] + cell[4] + cell[5] + cell[6] + cell[7] + V{1};
auto x11 = V{1} / (x10);
auto x12 = V{1}*x11;
auto x13 = -cell[17];
auto x14 = -cell[24];
auto x15 = x13 + x14 + cell[5];
auto x16 = -cell[19];
auto x17 = -cell[25];
auto x18 = x16 + x17 + cell[7];
auto x19 = -cell[23];
auto x20 = x19 - cell[26];
auto x21 = cell[10] + cell[11] + cell[4];
auto x22 = cell[12] + cell[6];
auto x23 = x15 + x18 + x20 + x21 + x22 + x7 - cell[14] - cell[18] - cell[20];
auto x24 = V{0.666666666666667}*cell[10];
auto x25 = V{0.666666666666667}*cell[11];
auto x26 = V{0.666666666666667}*cell[12];
auto x27 = V{0.666666666666667}*cell[13];
auto x28 = V{0.666666666666667}*cell[23];
auto x29 = V{0.666666666666667}*cell[24];
auto x30 = V{0.666666666666667}*cell[25];
auto x33 = V{0.666666666666667}*cell[26];
auto x34 = -V{0.333333333333333}*cell[0];
auto x35 = x24 + x25 + x26 + x27 + x28 + x29 + x30 + x33 + x34 - V{0.333333333333333}*cell[16] + V{0.666666666666667}*cell[17] + V{0.666666666666667}*cell[18] - V{0.333333333333333}*cell[3] + V{0.666666666666667}*cell[4] + V{0.666666666666667}*cell[5];
auto x36 = -V{0.333333333333333}*cell[15] + V{0.666666666666667}*cell[19] + V{0.666666666666667}*cell[20] - V{0.333333333333333}*cell[2] + V{0.666666666666667}*cell[6] + V{0.666666666666667}*cell[7];
auto x37 = -x12*x23*x23 + x35 + x36 + V{0.666666666666667}*cell[14] + V{0.666666666666667}*cell[1] - V{0.333333333333333}*cell[21] - V{0.333333333333333}*cell[22] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9];
auto x38 = -cell[12];
auto x39 = -cell[13] - cell[21];
auto x40 = x19 + x39;
auto x41 = x13 + x14 + x21 + x38 + x40 + x8 - cell[15] + cell[18] - cell[22] + cell[25] - cell[5] + cell[9];
auto x42 = -V{0.333333333333333}*cell[14] - V{0.333333333333333}*cell[1] + V{0.666666666666667}*cell[21] + V{0.666666666666667}*cell[22] + V{0.666666666666667}*cell[8] + V{0.666666666666667}*cell[9];
auto x43 = -x12*x41*x41 + x35 + x42 + V{0.666666666666667}*cell[15] - V{0.333333333333333}*cell[19] - V{0.333333333333333}*cell[20] + V{0.666666666666667}*cell[2] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7];
auto x44 = -cell[11];
auto x45 = x16 + x17 + x22 + x40 + x44 + x9 - cell[16] + cell[20] + cell[22] + cell[24] + cell[26] - cell[7] + cell[8] - cell[9];
auto x46 = -x12*x45*x45 + x24 + x25 + x26 + x27 + x28 + x29 + x30 + x33 + x34 + x36 + x42 + V{0.666666666666667}*cell[16] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.666666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5];
auto x47 = -x41;
auto x48 = -x11*x23;
auto x49 = -cell[10];
auto x50 = x19 + x49 + cell[13] + cell[26];
auto x51 = x15 + x3 + x44 + x47*x48 + x50 - cell[4];
auto x52 = -x45;
auto x53 = x18 + x38 + x48*x52 + x5 + x50 - cell[6];
auto x54 = x11*x47*x52 + x2 + x20 + x39 + x4 + x49 + x6 - cell[8];
auto x55 = -x0*(V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[19] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[20] + V{0.166666666666667}*cell[21] + V{0.166666666666667}*cell[22] + V{0.166666666666667}*cell[23] + V{0.166666666666667}*cell[24] + V{0.166666666666667}*cell[25] + V{0.166666666666667}*cell[26] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{0.166666666666667}) + util::sqrt(x10*(x1*util::sqrt(V{0.5}*(x37*x37) + V{0.5}*(x43*x43) + V{0.5}*(x46*x46) + x51*x51 + x53*x53 + x54*x54) + (V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[19] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[20] + V{0.0277777777777778}*cell[21] + V{0.0277777777777778}*cell[22] + V{0.0277777777777778}*cell[23] + V{0.0277777777777778}*cell[24] + V{0.0277777777777778}*cell[25] + V{0.0277777777777778}*cell[26] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778})/((x31)*(x31))));
return V{1} / (V{1}*x0 + V{3}*x1*util::sqrt((x55*x55)/(((x10)*(x10))*util::pow(x32, 4))));
}
 
};
 
 
template <typename... FIELDS>
struct KrauseEffectiveOmega<PerPopulationBGK,descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x21 = parameters.template get<olb::descriptors::OMEGA>();
auto x9 = V{0.5}/x21;
auto x10 = V{0.0130945659698734}/((x21)*(x21));
auto x11 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + V{1};
auto x12 = V{1} / (x11);
auto x13 = V{0.444444444444444}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444};
auto x14 = V{1} / ((x11)*(x11));
auto x15 = V{1.5}*x14;
auto x16 = cell[1] - cell[5];
auto x17 = cell[2] - cell[6];
auto x18 = x16 + x17 + cell[3] - cell[7];
auto x19 = x18*x18;
auto x20 = x15*x19;
auto x23 = -cell[4] + cell[8];
auto x24 = x16 + x23 - cell[3] + cell[7];
auto x25 = x24*x24;
auto x26 = x15*x25;
auto x27 = x26 + V{-1};
auto x28 = x20 + x27;
auto x29 = x22*x22;
auto x30 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(x13*x28 + cell[0] + V{0.444444444444444})));
auto x31 = -x18;
auto x32 = x15*(x31*x31);
auto x33 = x27 + x32;
auto x34 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778};
auto x35 = V{4.5}*x14;
auto x36 = x17 + x23 + V{2}*cell[1] - V{2}*cell[5];
auto x37 = x35*(x36*x36);
auto x38 = V{3}*cell[3];
auto x39 = V{3}*cell[7];
auto x40 = V{3}*cell[1] - V{3}*cell[5];
auto x41 = x38 - x39 + x40 + V{3}*cell[2] - V{3}*cell[6];
auto x42 = x12*x41;
auto x43 = -x26 + x42 + V{1};
auto x44 = -x38 + x39 + x40 - V{3}*cell[4] + V{3}*cell[8];
auto x45 = x12*x44;
auto x46 = -x20;
auto x47 = x45 + x46;
auto x48 = x34*(x37 + x43 + x47);
auto x49 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(-x48 + cell[1] + V{0.0277777777777778})));
auto x50 = V{0.111111111111111}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7] + V{0.111111111111111}*cell[8] + V{0.111111111111111};
auto x51 = V{3}*x14;
auto x52 = x50*(x19*x51 + x43);
auto x53 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(-x52 + cell[2] + V{0.111111111111111})));
auto x54 = -x12*x44;
auto x55 = x17 + V{2}*cell[3] + cell[4] - V{2}*cell[7] - cell[8];
auto x56 = -x55;
auto x57 = x35*(x56*x56);
auto x58 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(x34*(-x43 - x46 - x54 - x57) + cell[3] + V{0.0277777777777778})));
auto x59 = x25*x51;
auto x60 = x45 - x59 + V{-1};
auto x61 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(x50*(x20 + x60) + cell[4] + V{0.111111111111111})));
auto x62 = x28 + x42;
auto x63 = x34*(-x37 + x45 + x62) + V{0.0277777777777778};
auto x64 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(x63 + cell[5])));
auto x65 = x50*(V{3}*x14*x19 - x27 - x42);
auto x66 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(-x65 + cell[6] + V{0.111111111111111})));
auto x67 = -x34*(-V{4.5}*x14*x55*x55 + x54 + x62);
auto x68 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(-x67 + cell[7] + V{0.0277777777777778})));
auto x69 = x50*(x47 + x59 + V{1});
auto x70 = V{1} / (x9 + V{4.369426621423}*util::sqrt(x10 + x12*x29*util::fabs(-x69 + cell[8] + V{0.111111111111111})));
cell[0] = -x30*(x13*x33 + V{0.444444444444444}) + V{1}*(V{1} - x30)*cell[0];
cell[1] = x49*(x48 + V{-0.0277777777777778}) + V{1}*(V{1} - x49)*cell[1];
cell[2] = x53*(x52 + V{-0.111111111111111}) + V{1}*(V{1} - x53)*cell[2];
cell[3] = -x58*(x34*(-x12*x41 + x33 + x45 - x57) + V{0.0277777777777778}) + V{1}*(V{1} - x58)*cell[3];
cell[4] = -x61*(x50*(x32 + x60) + V{0.111111111111111}) + V{1}*(V{1} - x61)*cell[4];
cell[5] = -x63*x64 + V{1}*(V{1} - x64)*cell[5];
cell[6] = x66*(x65 + V{-0.111111111111111}) + V{1}*(V{1} - x66)*cell[6];
cell[7] = x68*(x67 + V{-0.0277777777777778}) + V{1}*(V{1} - x68)*cell[7];
cell[8] = x70*(x69 + V{-0.111111111111111}) + V{1}*(V{1} - x70)*cell[8];
return { x11, V{1}*x14*(x19 + x25) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x21 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = V{0.5}/x21;
auto x1 = V{0.0130945659698734}/((x21)*(x21));
auto x2 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + V{1};
auto x3 = V{1} / (x2);
auto x4 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778};
auto x5 = V{3}*cell[7];
auto x6 = V{3}*cell[3];
auto x7 = V{3}*cell[1] - V{3}*cell[5];
auto x8 = x5 - x6 + x7 - V{3}*cell[4] + V{3}*cell[8];
auto x9 = x3*x8;
auto x10 = V{1} / ((x2)*(x2));
auto x11 = V{4.5}*x10;
auto x12 = -cell[4] + cell[8];
auto x13 = cell[2] - cell[6];
auto x14 = x12 + x13 + V{2}*cell[1] - V{2}*cell[5];
auto x15 = x11*(x14*x14);
auto x16 = x3*(-x5 + x6 + x7 + V{3}*cell[2] - V{3}*cell[6]);
auto x17 = V{1.5}*x10;
auto x18 = cell[1] - cell[5];
auto x19 = x12 + x18 - cell[3] + cell[7];
auto x20 = x19*x19;
auto x23 = x17*x20;
auto x24 = x13 + x18 + cell[3] - cell[7];
auto x25 = x24*x24;
auto x26 = x17*x25;
auto x27 = x26 + V{-1};
auto x28 = x23 + x27;
auto x29 = x16 + x28;
auto x30 = x22*x22;
auto x31 = -x26;
auto x32 = -x3*x8;
auto x33 = x13 + V{2}*cell[3] + cell[4] - V{2}*cell[7] - cell[8];
auto x34 = -x33;
auto x35 = x16 - x23 + V{1};
auto x36 = x31 + x9;
auto x37 = V{0.111111111111111}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7] + V{0.111111111111111}*cell[8] + V{0.111111111111111};
auto x38 = V{3}*x10;
auto x39 = x20*x38;
return V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(-x4*(x11*(x34*x34) + x31 + x32 + x35) + cell[3] + V{0.0277777777777778}))) + V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(x4*(-V{4.5}*x10*x33*x33 + x29 + x32) + cell[7] + V{0.0277777777777778}))) + V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(-x4*(x15 + x35 + x36) + cell[1] + V{0.0277777777777778}))) + V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(x4*(-x15 + x29 + x9) + cell[5] + V{0.0277777777777778}))) + V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(-x37*(V{3}*x10*x25 - x16 - x23 + V{1}) + cell[6] + V{0.111111111111111}))) + V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(-x37*(x36 + x39 + V{1}) + cell[8] + V{0.111111111111111}))) + V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(x37*(x27 - x39 + x9) + cell[4] + V{0.111111111111111}))) + V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(-x37*(x25*x38 + x35) + cell[2] + V{0.111111111111111}))) + V{0.111111111111111}/(x0 + V{4.369426621423}*util::sqrt(x1 + x3*x30*util::fabs(x28*(V{0.444444444444444}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}) + cell[0] + V{0.444444444444444})));
}
 
};
 
template <typename... FIELDS>
struct KrauseEffectiveOmega<PerPopulationBGK,descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x43 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x42 = parameters.template get<olb::descriptors::OMEGA>();
auto x19 = V{0.5}/x42;
auto x20 = V{0.0130945659698734}/((x42)*(x42));
auto x21 = cell[10] + cell[14];
auto x22 = cell[12] + cell[7];
auto x23 = x21 + x22 + cell[0] + cell[11] + cell[13] + cell[15] + cell[16] + cell[17] + cell[18] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + cell[9] + V{1};
auto x24 = V{1} / (x23);
auto x25 = V{1} / ((x23)*(x23));
auto x26 = V{1.5}*x25;
auto x27 = cell[13] - cell[4];
auto x28 = cell[15] - cell[6];
auto x29 = x27 + x28;
auto x30 = -cell[1];
auto x31 = cell[16] - cell[7];
auto x32 = x30 + x31;
auto x33 = x21 - cell[5];
auto x34 = x29 + x32 + x33;
auto x35 = x34*x34;
auto x36 = x26*x35;
auto x37 = cell[17] - cell[8];
auto x38 = x27 + x37;
auto x39 = cell[18] - cell[9];
auto x40 = -cell[2];
auto x41 = x40 + cell[11] - cell[14] + cell[5];
auto x44 = x38 + x39 + x41;
auto x45 = x44*x44;
auto x46 = x26*x45;
auto x47 = x28 + x37;
auto x48 = -cell[3];
auto x49 = -cell[18] + cell[9];
auto x50 = x48 + x49;
auto x51 = x22 - cell[16];
auto x52 = x47 + x50 + x51;
auto x53 = x52*x52;
auto x54 = x26*x53;
auto x55 = x46 + x54 + V{-1};
auto x56 = x36 + x55;
auto x57 = x56*(V{0.333333333333333}*cell[0] + V{0.333333333333333}*cell[10] + V{0.333333333333333}*cell[11] + V{0.333333333333333}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9] + V{0.333333333333333}) + V{0.333333333333333};
auto x58 = x43*x43;
auto x59 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x57 + cell[0])));
auto x60 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[10] + V{0.0555555555555556}*cell[11] + V{0.0555555555555556}*cell[12] + V{0.0555555555555556}*cell[13] + V{0.0555555555555556}*cell[14] + V{0.0555555555555556}*cell[15] + V{0.0555555555555556}*cell[16] + V{0.0555555555555556}*cell[17] + V{0.0555555555555556}*cell[18] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556}*cell[9] + V{0.0555555555555556};
auto x61 = V{3}*cell[14];
auto x62 = V{3}*cell[16];
auto x63 = V{3}*cell[5];
auto x64 = V{3}*cell[7];
auto x65 = V{3}*cell[13] - V{3}*cell[4];
auto x66 = V{3}*cell[15] - V{3}*cell[6];
auto x67 = x24*(x61 + x62 - x63 - x64 + x65 + x66 + V{3}*cell[10] - V{3}*cell[1]);
auto x68 = V{3}*x25;
auto x69 = x35*x68;
auto x70 = x60*(x55 + x67 - x69) + V{0.0555555555555556};
auto x71 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x70 + cell[1])));
auto x72 = V{3}*cell[18];
auto x73 = V{3}*cell[9];
auto x74 = V{3}*cell[17] - V{3}*cell[8];
auto x75 = x24*(-x61 + x63 + x65 + x72 - x73 + x74 + V{3}*cell[11] - V{3}*cell[2]);
auto x76 = x45*x68;
auto x77 = x36 + V{-1};
auto x78 = x60*(x54 + x75 - x76 + x77) + V{0.0555555555555556};
auto x79 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x78 + cell[2])));
auto x80 = x24*(-x62 + x64 + x66 - x72 + x73 + x74 + V{3}*cell[12] - V{3}*cell[3]);
auto x81 = x53*x68;
auto x82 = x60*(x46 + x77 + x80 - x81) + V{0.0555555555555556};
auto x83 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x82 + cell[3])));
auto x84 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x85 = V{4.5}*x25;
auto x86 = x32 + cell[10];
auto x87 = x39 + x40 + x47 + x86 + cell[11] + V{2}*cell[13] - V{2}*cell[4];
auto x88 = x85*(x87*x87);
auto x89 = x56 + x67;
auto x90 = x84*(x75 - x88 + x89) + V{0.0277777777777778};
auto x91 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x90 + cell[4])));
auto x92 = -cell[17] + cell[8];
auto x93 = x28 + x49 + x86 + x92 - cell[11] + V{2}*cell[14] + cell[2] - V{2}*cell[5];
auto x94 = -x85*x93*x93;
auto x95 = -x75;
auto x96 = x89 + x95;
auto x97 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x84*(x94 + x96) + cell[5] + V{0.0277777777777778})));
auto x98 = -x93;
auto x99 = x30 + x33;
auto x100 = x38 + x50 + x99 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x101 = x85*(x100*x100);
auto x102 = x84*(-x101 + x80 + x89) + V{0.0277777777777778};
auto x103 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x102 + cell[6])));
auto x104 = x27 - cell[12] + cell[3];
auto x105 = x104 + x39 + x92 + x99 + V{2}*cell[16] - V{2}*cell[7];
auto x106 = -x85*x105*x105;
auto x107 = -x80;
auto x108 = x107 + x89;
auto x109 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x84*(x106 + x108) + cell[7] + V{0.0277777777777778})));
auto x110 = -x105;
auto x111 = x29 + x41 + x48 + x51 + V{2}*cell[17] - V{2}*cell[8];
auto x112 = x85*(x111*x111);
auto x113 = x56 + x75;
auto x114 = x84*(-x112 + x113 + x80) + V{0.0277777777777778};
auto x115 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x114 + cell[8])));
auto x116 = x104 + x31 + x41 - cell[15] + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x117 = -x85*x116*x116;
auto x118 = x107 + x113;
auto x119 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x84*(x117 + x118) + cell[9] + V{0.0277777777777778})));
auto x120 = -x116;
auto x121 = -x46;
auto x122 = V{1} - x54;
auto x123 = x121 + x122;
auto x124 = x123 + x67;
auto x125 = x60*(x124 + x69);
auto x126 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(-x125 + cell[10] + V{0.0555555555555556})));
auto x127 = -x36;
auto x128 = x127 + x75;
auto x129 = x60*(x122 + x128 + x76);
auto x130 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(-x129 + cell[11] + V{0.0555555555555556})));
auto x131 = x127 + x80;
auto x132 = x60*(x121 + x131 + x81 + V{1});
auto x133 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(-x132 + cell[12] + V{0.0555555555555556})));
auto x134 = x84*(x124 + x128 + x88);
auto x135 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(-x134 + cell[13] + V{0.0277777777777778})));
auto x136 = -x67;
auto x137 = x84*(x113 + x136 + x94) + V{0.0277777777777778};
auto x138 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x137 + cell[14])));
auto x139 = x84*(x101 + x124 + x131);
auto x140 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(-x139 + cell[15] + V{0.0277777777777778})));
auto x141 = x56 + x80;
auto x142 = x84*(x106 + x136 + x141) + V{0.0277777777777778};
auto x143 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x142 + cell[16])));
auto x144 = x84*(x112 + x123 + x128 + x80);
auto x145 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(-x144 + cell[17] + V{0.0277777777777778})));
auto x146 = x84*(x117 + x141 + x95) + V{0.0277777777777778};
auto x147 = V{1} / (x19 + V{4.369426621423}*util::sqrt(x20 + x24*x58*util::fabs(x146 + cell[18])));
cell[0] = -x57*x59 + V{1}*(V{1} - x59)*cell[0];
cell[1] = -x70*x71 + V{1}*(V{1} - x71)*cell[1];
cell[2] = -x78*x79 + V{1}*(V{1} - x79)*cell[2];
cell[3] = -x82*x83 + V{1}*(V{1} - x83)*cell[3];
cell[4] = -x90*x91 + V{1}*(V{1} - x91)*cell[4];
cell[5] = -x97*(x84*(-x85*x98*x98 + x96) + V{0.0277777777777778}) + V{1}*(V{1} - x97)*cell[5];
cell[6] = -x102*x103 + V{1}*(V{1} - x103)*cell[6];
cell[7] = -x109*(x84*(x108 - x85*x110*x110) + V{0.0277777777777778}) + V{1}*(V{1} - x109)*cell[7];
cell[8] = -x114*x115 + V{1}*(V{1} - x115)*cell[8];
cell[9] = -x119*(x84*(x118 - x85*x120*x120) + V{0.0277777777777778}) + V{1}*(V{1} - x119)*cell[9];
cell[10] = x126*(x125 + V{-0.0555555555555556}) + V{1}*(V{1} - x126)*cell[10];
cell[11] = x130*(x129 + V{-0.0555555555555556}) + V{1}*(V{1} - x130)*cell[11];
cell[12] = x133*(x132 + V{-0.0555555555555556}) + V{1}*(V{1} - x133)*cell[12];
cell[13] = x135*(x134 + V{-0.0277777777777778}) + V{1}*(V{1} - x135)*cell[13];
cell[14] = -x137*x138 + V{1}*(V{1} - x138)*cell[14];
cell[15] = x140*(x139 + V{-0.0277777777777778}) + V{1}*(V{1} - x140)*cell[15];
cell[16] = -x142*x143 + V{1}*(V{1} - x143)*cell[16];
cell[17] = x145*(x144 + V{-0.0277777777777778}) + V{1}*(V{1} - x145)*cell[17];
cell[18] = -x146*x147 + V{1}*(V{1} - x147)*cell[18];
return { x23, V{1}*x25*(x35 + x45 + x53) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x42 = parameters.template get<olb::descriptors::OMEGA>();
auto x43 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x0 = V{0.5}/x42;
auto x1 = V{0.0130945659698734}/((x42)*(x42));
auto x2 = cell[10] + cell[14];
auto x3 = cell[12] + cell[7];
auto x4 = cell[3] + cell[6];
auto x5 = x2 + x3 + x4 + cell[0] + cell[11] + cell[13] + cell[15] + cell[16] + cell[17] + cell[18] + cell[1] + cell[2] + cell[4] + cell[5] + cell[8] + cell[9] + V{1};
auto x6 = V{1} / (x5);
auto x7 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x8 = V{3}*cell[7];
auto x9 = V{3}*cell[9];
auto x10 = V{3}*cell[16];
auto x11 = V{3}*cell[18];
auto x12 = V{3}*cell[17] - V{3}*cell[8];
auto x13 = V{3}*cell[15] - V{3}*cell[6];
auto x14 = x6*(-x10 - x11 + x12 + x13 + x8 + x9 + V{3}*cell[12] - V{3}*cell[3]);
auto x15 = V{1} / ((x5)*(x5));
auto x16 = V{4.5}*x15;
auto x17 = cell[13] - cell[4];
auto x18 = cell[15] - cell[6];
auto x19 = x17 + x18;
auto x20 = -cell[2];
auto x21 = x20 + cell[11] - cell[14] + cell[5];
auto x22 = -cell[3];
auto x23 = x22 + x3 - cell[16];
auto x24 = x19 + x21 + x23 + V{2}*cell[17] - V{2}*cell[8];
auto x25 = x16*(x24*x24);
auto x26 = V{3}*cell[5];
auto x27 = V{3}*cell[14];
auto x28 = V{3}*cell[13] - V{3}*cell[4];
auto x29 = x6*(x11 + x12 + x26 - x27 + x28 - x9 + V{3}*cell[11] - V{3}*cell[2]);
auto x30 = V{1.5}*x15;
auto x31 = cell[17] - cell[8];
auto x32 = x17 + x31;
auto x33 = cell[18] - cell[9];
auto x34 = x21 + x32 + x33;
auto x35 = x34*x34;
auto x36 = x30*x35;
auto x37 = -cell[1];
auto x38 = cell[16] - cell[7];
auto x39 = x37 + x38;
auto x40 = x2 - cell[5];
auto x41 = x19 + x39 + x40;
auto x44 = x41*x41;
auto x45 = x30*x44;
auto x46 = x18 + x31;
auto x47 = -cell[18] + cell[9];
auto x48 = x23 + x46 + x47;
auto x49 = x48*x48;
auto x50 = x30*x49;
auto x51 = x45 + x50 + V{-1};
auto x52 = x36 + x51;
auto x53 = x29 + x52;
auto x54 = x43*x43;
auto x55 = x6*(x10 + x13 - x26 + x27 + x28 - x8 + V{3}*cell[10] - V{3}*cell[1]);
auto x56 = x39 + cell[10];
auto x57 = x20 + x33 + x46 + x56 + cell[11] + V{2}*cell[13] - V{2}*cell[4];
auto x58 = x16*(x57*x57);
auto x59 = -x14;
auto x60 = x17 - cell[12];
auto x61 = x21 + x38 + x4 + x60 - cell[15] + V{2}*cell[18] - V{2}*cell[9];
auto x62 = -x16*x61*x61;
auto x63 = -x55;
auto x64 = -cell[17] + cell[8];
auto x65 = x18 + x47 + x56 + x64 - cell[11] + V{2}*cell[14] + cell[2] - V{2}*cell[5];
auto x66 = -x16*x65*x65;
auto x67 = x37 + x40;
auto x68 = x22 + x32 + x47 + x67 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x69 = x16*(x68*x68);
auto x70 = x14 + x52;
auto x71 = -x29;
auto x72 = x33 + x60 + x64 + x67 + V{2}*cell[16] + cell[3] - V{2}*cell[7];
auto x73 = -x16*x72*x72;
auto x74 = x52 + x55;
auto x75 = -x50;
auto x76 = V{1} - x45;
auto x77 = x75 + x76;
auto x78 = x29 + x77;
auto x79 = -x36;
auto x80 = x14 + x79;
auto x81 = x55 + x79;
auto x82 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[10] + V{0.0555555555555556}*cell[11] + V{0.0555555555555556}*cell[12] + V{0.0555555555555556}*cell[13] + V{0.0555555555555556}*cell[14] + V{0.0555555555555556}*cell[15] + V{0.0555555555555556}*cell[16] + V{0.0555555555555556}*cell[17] + V{0.0555555555555556}*cell[18] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556}*cell[9] + V{0.0555555555555556};
auto x83 = V{3}*x15;
auto x84 = x35*x83;
auto x85 = x49*x83;
auto x86 = x36 + V{-1};
auto x87 = x44*x83;
return V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(-x82*(x75 + x81 + x87 + V{1}) + cell[10] + V{0.0555555555555556}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x82*(x50 + x55 + x86 - x87) + cell[1] + V{0.0555555555555556}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x82*(x14 + x45 - x85 + x86) + cell[3] + V{0.0555555555555556}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(-x82*(x76 + x80 + x85) + cell[12] + V{0.0555555555555556}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x82*(x29 + x51 - x84) + cell[2] + V{0.0555555555555556}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(-x82*(x78 + x84) + cell[11] + V{0.0555555555555556}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(-x7*(x55 + x69 + x77 + x80) + cell[15] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x66 + x71 + x74) + cell[5] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x63 + x70 + x73) + cell[16] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x62 + x70 + x71) + cell[18] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x59 + x73 + x74) + cell[7] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(-x7*(x58 + x78 + x81) + cell[13] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x55 - x69 + x70) + cell[6] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x53 + x63 + x66) + cell[14] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x53 + x59 + x62) + cell[9] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x53 + x55 - x58) + cell[4] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(-x7*(x25 + x78 + x80) + cell[17] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x7*(x14 - x25 + x53) + cell[8] + V{0.0277777777777778}))) + V{0.0526315789473684}/(x0 + V{4.369426621423}*util::sqrt(x1 + x54*x6*util::fabs(x52*(V{0.333333333333333}*cell[0] + V{0.333333333333333}*cell[10] + V{0.333333333333333}*cell[11] + V{0.333333333333333}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9] + V{0.333333333333333}) + cell[0] + V{0.333333333333333})));
}
 
};
 
template <typename... FIELDS>
struct KrauseEffectiveOmega<PerPopulationBGK,descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x58 = parameters.template get<olb::descriptors::OMEGA>();
auto x59 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x27 = V{0.5}/x58;
auto x28 = V{0.0130945659698734}/((x58)*(x58));
auto x29 = cell[15] + cell[21];
auto x30 = cell[12] + cell[26];
auto x31 = x29 + x30 + cell[0] + cell[10] + cell[11] + cell[13] + cell[14] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[22] + cell[23] + cell[24] + cell[25] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1};
auto x32 = V{1} / (x31);
auto x33 = V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296};
auto x34 = V{1} / ((x31)*(x31));
auto x35 = V{1.5}*x34;
auto x36 = -cell[19];
auto x37 = -cell[25];
auto x38 = x36 + x37 + cell[12] + cell[6];
auto x39 = -cell[14];
auto x40 = cell[11] - cell[24];
auto x41 = x39 + x40 + cell[1];
auto x42 = -cell[18] + cell[5];
auto x43 = -cell[17];
auto x44 = x43 + cell[4];
auto x45 = -cell[20] + cell[7];
auto x46 = x44 + x45;
auto x47 = cell[10] - cell[23];
auto x48 = x47 + cell[13] - cell[26];
auto x49 = x38 + x41 + x42 + x46 + x48;
auto x50 = x49*x49;
auto x51 = x35*x50;
auto x52 = -cell[21];
auto x53 = x43 + x52 + cell[4] + cell[8];
auto x54 = -cell[13];
auto x55 = x47 + x54 + cell[26];
auto x56 = -cell[15];
auto x57 = -cell[22] + cell[9];
auto x60 = x56 + x57 + cell[2];
auto x61 = cell[18] - cell[5];
auto x62 = -cell[12] + cell[25];
auto x63 = x40 + x53 + x55 + x60 + x61 + x62;
auto x64 = x63*x63;
auto x65 = x35*x64;
auto x66 = x52 + cell[8];
auto x67 = -cell[16];
auto x68 = cell[22] - cell[9];
auto x69 = x67 + x68 + cell[3];
auto x70 = -cell[11] + cell[24];
auto x71 = cell[20] - cell[7];
auto x72 = x38 + x55 + x66 + x69 + x70 + x71;
auto x73 = x72*x72;
auto x74 = x35*x73;
auto x75 = x65 + x74 + V{-1};
auto x76 = x51 + x75;
auto x77 = x59*x59;
auto x78 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x33*x76 + cell[0] + V{0.296296296296296})));
auto x79 = -x49;
auto x80 = x79*x79;
auto x81 = x35*x80;
auto x82 = -x63;
auto x83 = x82*x82;
auto x84 = x35*x83;
auto x85 = -x72;
auto x86 = x85*x85;
auto x87 = x35*x86;
auto x88 = x84 + x87 + V{-1};
auto x89 = x81 + x88;
auto x90 = V{0.0740740740740741}*cell[0] + V{0.0740740740740741}*cell[10] + V{0.0740740740740741}*cell[11] + V{0.0740740740740741}*cell[12] + V{0.0740740740740741}*cell[13] + V{0.0740740740740741}*cell[14] + V{0.0740740740740741}*cell[15] + V{0.0740740740740741}*cell[16] + V{0.0740740740740741}*cell[17] + V{0.0740740740740741}*cell[18] + V{0.0740740740740741}*cell[19] + V{0.0740740740740741}*cell[1] + V{0.0740740740740741}*cell[20] + V{0.0740740740740741}*cell[21] + V{0.0740740740740741}*cell[22] + V{0.0740740740740741}*cell[23] + V{0.0740740740740741}*cell[24] + V{0.0740740740740741}*cell[25] + V{0.0740740740740741}*cell[26] + V{0.0740740740740741}*cell[2] + V{0.0740740740740741}*cell[3] + V{0.0740740740740741}*cell[4] + V{0.0740740740740741}*cell[5] + V{0.0740740740740741}*cell[6] + V{0.0740740740740741}*cell[7] + V{0.0740740740740741}*cell[8] + V{0.0740740740740741}*cell[9] + V{0.0740740740740741};
auto x91 = V{3}*x34;
auto x92 = x50*x91;
auto x93 = V{3}*cell[5];
auto x94 = V{3}*cell[7];
auto x95 = V{3}*cell[13];
auto x96 = V{3}*cell[18];
auto x97 = V{3}*cell[20];
auto x98 = V{3}*cell[26];
auto x99 = V{3}*cell[10];
auto x100 = V{3}*cell[11];
auto x101 = -V{3}*cell[23];
auto x102 = V{3}*cell[24];
auto x103 = x100 + x101 - x102 + x99 - V{3}*cell[17] + V{3}*cell[4];
auto x104 = V{3}*cell[12];
auto x105 = V{3}*cell[25];
auto x106 = x104 - x105 - V{3}*cell[19] + V{3}*cell[6];
auto x107 = x103 + x106 + x93 + x94 + x95 - x96 - x97 - x98 - V{3}*cell[14] + V{3}*cell[1];
auto x108 = x107*x32;
auto x109 = -V{1.5}*x34*x64;
auto x110 = -V{1.5}*x34*x73 + V{1};
auto x111 = x109 + x110;
auto x112 = x108 + x111;
auto x113 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x90*(-x112 - x92) + cell[1] + V{0.0740740740740741})));
auto x114 = -x107*x32;
auto x115 = x64*x91;
auto x116 = V{3}*cell[9];
auto x117 = V{3}*cell[22];
auto x118 = -x95 + x98 - V{3}*cell[21] + V{3}*cell[8];
auto x119 = x103 - x104 + x105 + x116 - x117 + x118 - x93 + x96 - V{3}*cell[15] + V{3}*cell[2];
auto x120 = x119*x32;
auto x121 = -V{1.5}*x34*x50;
auto x122 = x120 + x121;
auto x123 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x90*(-x110 - x115 - x122) + cell[2] + V{0.0740740740740741})));
auto x124 = -x119*x32;
auto x125 = x81 + V{-1};
auto x126 = x73*x91;
auto x127 = -x100 + x101 + x102 + x106 - x116 + x117 + x118 - x94 + x97 + x99 - V{3}*cell[16] + V{3}*cell[3];
auto x128 = x127*x32;
auto x129 = x121 + x128;
auto x130 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x90*(-x109 - x126 - x129 + V{-1}) + cell[3] + V{0.0740740740740741})));
auto x131 = -x127*x32;
auto x132 = V{0.0185185185185185}*cell[0] + V{0.0185185185185185}*cell[10] + V{0.0185185185185185}*cell[11] + V{0.0185185185185185}*cell[12] + V{0.0185185185185185}*cell[13] + V{0.0185185185185185}*cell[14] + V{0.0185185185185185}*cell[15] + V{0.0185185185185185}*cell[16] + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[1] + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[23] + V{0.0185185185185185}*cell[24] + V{0.0185185185185185}*cell[25] + V{0.0185185185185185}*cell[26] + V{0.0185185185185185}*cell[2] + V{0.0185185185185185}*cell[3] + V{0.0185185185185185}*cell[4] + V{0.0185185185185185}*cell[5] + V{0.0185185185185185}*cell[6] + V{0.0185185185185185}*cell[7] + V{0.0185185185185185}*cell[8] + V{0.0185185185185185}*cell[9] + V{0.0185185185185185};
auto x133 = V{4.5}*x34;
auto x134 = V{2}*cell[11] - V{2}*cell[24];
auto x135 = -V{2}*cell[17] + V{2}*cell[4];
auto x136 = -V{2}*cell[23];
auto x137 = V{2}*cell[10];
auto x138 = x39 + cell[1];
auto x139 = x136 + x137 + x138;
auto x140 = x36 + cell[6];
auto x141 = x140 + x45;
auto x142 = x134 + x135 + x139 + x141 + x60 + x66;
auto x143 = -x142;
auto x144 = x133*(x143*x143);
auto x145 = x112 + x122;
auto x146 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(-x144 - x145) + cell[4] + V{0.0185185185185185})));
auto x147 = x114 + x89;
auto x148 = x124 + x147;
auto x149 = V{2}*cell[25];
auto x150 = V{2}*cell[12];
auto x151 = -x149 + x150;
auto x152 = V{2}*cell[26];
auto x153 = V{2}*cell[13];
auto x154 = x138 - x152 + x153 - cell[8];
auto x155 = V{2}*cell[18];
auto x156 = V{2}*cell[5];
auto x157 = -x155 + x156 - cell[2];
auto x158 = x141 + x151 + x154 + x157 + x29 + x68;
auto x159 = -x158;
auto x160 = -x133*x159*x159;
auto x161 = -x108;
auto x162 = x161 + x76;
auto x163 = x120 + x162;
auto x164 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(x160 + x163) + cell[5] + V{0.0185185185185185})));
auto x165 = -x124;
auto x166 = x147 + x165;
auto x167 = -V{2}*cell[19] + V{2}*cell[6];
auto x168 = x139 + x151 + x167 + x42 + x53 + x69;
auto x169 = -x168;
auto x170 = x133*(x169*x169);
auto x171 = x112 + x129;
auto x172 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(-x170 - x171) + cell[6] + V{0.0185185185185185})));
auto x173 = -cell[3];
auto x174 = x134 + x173 + cell[16];
auto x175 = V{2}*cell[20];
auto x176 = V{2}*cell[7];
auto x177 = -x175 + x176;
auto x178 = x154 + x174 + x177 + x42 + x44 + x57 + cell[21];
auto x179 = -x178;
auto x180 = -x133*x179*x179;
auto x181 = x128 + x162;
auto x182 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(x180 + x181) + cell[7] + V{0.0185185185185185})));
auto x183 = -x131;
auto x184 = x56 + cell[2];
auto x185 = x184 + x61;
auto x186 = x67 + cell[3];
auto x187 = x186 - V{2}*cell[21] + V{2}*cell[8];
auto x188 = x136 + x137 + x140 + x152 - x153 + x185 + x187 + x44 + x71;
auto x189 = -x188;
auto x190 = x133*(x189*x189);
auto x191 = x111 + x122 + x128;
auto x192 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(-x190 - x191) + cell[8] + V{0.0185185185185185})));
auto x193 = x124 + x89;
auto x194 = x131 + x193;
auto x195 = V{2}*cell[22];
auto x196 = V{2}*cell[9];
auto x197 = -x195 + x196;
auto x198 = x149 - x150 + x174 + x185 + x197 + x46 + cell[19] - cell[6];
auto x199 = -x198;
auto x200 = -x133*x199*x199;
auto x201 = -x120;
auto x202 = x201 + x76;
auto x203 = x128 + x202;
auto x204 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(x200 + x203) + cell[9] + V{0.0185185185185185})));
auto x205 = V{0.00462962962962963}*cell[0] + V{0.00462962962962963}*cell[10] + V{0.00462962962962963}*cell[11] + V{0.00462962962962963}*cell[12] + V{0.00462962962962963}*cell[13] + V{0.00462962962962963}*cell[14] + V{0.00462962962962963}*cell[15] + V{0.00462962962962963}*cell[16] + V{0.00462962962962963}*cell[17] + V{0.00462962962962963}*cell[18] + V{0.00462962962962963}*cell[19] + V{0.00462962962962963}*cell[1] + V{0.00462962962962963}*cell[20] + V{0.00462962962962963}*cell[21] + V{0.00462962962962963}*cell[22] + V{0.00462962962962963}*cell[23] + V{0.00462962962962963}*cell[24] + V{0.00462962962962963}*cell[25] + V{0.00462962962962963}*cell[26] + V{0.00462962962962963}*cell[2] + V{0.00462962962962963}*cell[3] + V{0.00462962962962963}*cell[4] + V{0.00462962962962963}*cell[5] + V{0.00462962962962963}*cell[6] + V{0.00462962962962963}*cell[7] + V{0.00462962962962963}*cell[8] + V{0.00462962962962963}*cell[9] + V{0.00462962962962963};
auto x206 = x135 + x184;
auto x207 = x167 + x187 + x206 + x30 + x37 + x41 + x54 + V{3}*cell[10] - V{3}*cell[23];
auto x208 = -x207;
auto x209 = x133*(x208*x208);
auto x210 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x205*(-x128 - x145 - x209) + cell[10] + V{0.00462962962962963})));
auto x211 = x138 + x48;
auto x212 = x173 + x177 + x197 + x206 + x211 + x62 + V{3}*cell[11] + cell[16] - V{3}*cell[24];
auto x213 = -x212;
auto x214 = -x133*x213*x213;
auto x215 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x205*(x181 + x201 + x214) + cell[11] + V{0.00462962962962963})));
auto x216 = x157 + x167 + x186 + x195 - x196 + x211 + x70 + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x217 = -x216;
auto x218 = x133*(x217*x217);
auto x219 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x205*(-x171 - x201 - x218) + cell[12] + V{0.00462962962962963})));
auto x220 = x155 - x156 + x175 - x176 + x184 + x187 + x47 + x62 + x70 - V{3}*cell[13] + cell[14] - cell[1] + V{3}*cell[26];
auto x221 = -x220;
auto x222 = x133*(x221*x221);
auto x223 = x205*(x128 + x163 - x222) + V{0.00462962962962963};
auto x224 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x223 + cell[13])));
auto x225 = x90*(x108 + x75 - x92) + V{0.0740740740740741};
auto x226 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x225 + cell[14])));
auto x227 = x51 + V{-1};
auto x228 = x90*(-x115 + x120 + x227 + x74) + V{0.0740740740740741};
auto x229 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x228 + cell[15])));
auto x230 = x90*(-x126 + x128 + x227 + x65) + V{0.0740740740740741};
auto x231 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x230 + cell[16])));
auto x232 = x108 + x76;
auto x233 = x120 + x232;
auto x234 = x132*(-x133*x142*x142 + x233) + V{0.0185185185185185};
auto x235 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x234 + cell[17])));
auto x236 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(x108 + x160 + x202) + cell[18] + V{0.0185185185185185})));
auto x237 = -x114;
auto x238 = x132*(x128 - x133*x168*x168 + x232) + V{0.0185185185185185};
auto x239 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x238 + cell[19])));
auto x240 = -x128;
auto x241 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(x180 + x232 + x240) + cell[20] + V{0.0185185185185185})));
auto x242 = x131 + x89;
auto x243 = x120 + x76;
auto x244 = x132*(x128 - x133*x188*x188 + x243) + V{0.0185185185185185};
auto x245 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x244 + cell[21])));
auto x246 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x132*(x200 + x240 + x243) + cell[22] + V{0.0185185185185185})));
auto x247 = x205*(x128 - x133*x207*x207 + x233) + V{0.00462962962962963};
auto x248 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x247 + cell[23])));
auto x249 = x205*(x214 + x233 + x240) + V{0.00462962962962963};
auto x250 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x249 + cell[24])));
auto x251 = x205*(x108 + x203 - x218) + V{0.00462962962962963};
auto x252 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x251 + cell[25])));
auto x253 = V{1} / (x27 + V{4.369426621423}*util::sqrt(x28 + x32*x77*util::fabs(x205*(-x161 - x191 - x222) + cell[26] + V{0.00462962962962963})));
cell[0] = -x78*(x33*x89 + V{0.296296296296296}) + V{1}*(V{1} - x78)*cell[0];
cell[1] = -x113*(x90*(x114 - x80*x91 + x88) + V{0.0740740740740741}) + V{1}*(V{1} - x113)*cell[1];
cell[2] = -x123*(x90*(x124 + x125 - x83*x91 + x87) + V{0.0740740740740741}) + V{1}*(V{1} - x123)*cell[2];
cell[3] = -x130*(x90*(x125 + x131 + x84 - x86*x91) + V{0.0740740740740741}) + V{1}*(V{1} - x130)*cell[3];
cell[4] = -x146*(x132*(-x144 + x148) + V{0.0185185185185185}) + V{1}*(V{1} - x146)*cell[4];
cell[5] = -x164*(x132*(-x133*x158*x158 + x166) + V{0.0185185185185185}) + V{1}*(V{1} - x164)*cell[5];
cell[6] = -x172*(x132*(x131 + x147 - x170) + V{0.0185185185185185}) + V{1}*(V{1} - x172)*cell[6];
cell[7] = -x182*(x132*(-x133*x178*x178 + x147 + x183) + V{0.0185185185185185}) + V{1}*(V{1} - x182)*cell[7];
cell[8] = -x192*(x132*(-x190 + x194) + V{0.0185185185185185}) + V{1}*(V{1} - x192)*cell[8];
cell[9] = -x204*(x132*(-x133*x198*x198 + x183 + x193) + V{0.0185185185185185}) + V{1}*(V{1} - x204)*cell[9];
cell[10] = -x210*(x205*(x131 + x148 - x209) + V{0.00462962962962963}) + V{1}*(V{1} - x210)*cell[10];
cell[11] = -x215*(x205*(-x133*x212*x212 + x148 + x183) + V{0.00462962962962963}) + V{1}*(V{1} - x215)*cell[11];
cell[12] = -x219*(x205*(x131 - x133*x216*x216 + x166) + V{0.00462962962962963}) + V{1}*(V{1} - x219)*cell[12];
cell[13] = -x223*x224 + V{1}*(V{1} - x224)*cell[13];
cell[14] = -x225*x226 + V{1}*(V{1} - x226)*cell[14];
cell[15] = -x228*x229 + V{1}*(V{1} - x229)*cell[15];
cell[16] = -x230*x231 + V{1}*(V{1} - x231)*cell[16];
cell[17] = -x234*x235 + V{1}*(V{1} - x235)*cell[17];
cell[18] = -x236*(x132*(x160 + x193 + x237) + V{0.0185185185185185}) + V{1}*(V{1} - x236)*cell[18];
cell[19] = -x238*x239 + V{1}*(V{1} - x239)*cell[19];
cell[20] = -x241*(x132*(x180 + x237 + x242) + V{0.0185185185185185}) + V{1}*(V{1} - x241)*cell[20];
cell[21] = -x244*x245 + V{1}*(V{1} - x245)*cell[21];
cell[22] = -x246*(x132*(x165 + x200 + x242) + V{0.0185185185185185}) + V{1}*(V{1} - x246)*cell[22];
cell[23] = -x247*x248 + V{1}*(V{1} - x248)*cell[23];
cell[24] = -x249*x250 + V{1}*(V{1} - x250)*cell[24];
cell[25] = -x251*x252 + V{1}*(V{1} - x252)*cell[25];
cell[26] = -x253*(x205*(-x133*x220*x220 + x194 + x237) + V{0.00462962962962963}) + V{1}*(V{1} - x253)*cell[26];
return { x31, V{1}*x34*(x50 + x64 + x73) };
}
 
template <typename CELL, typename PARAMETERS, typename V=typename CELL::value_t>
auto computeEffectiveOmega(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x59 = parameters.template get<olb::collision::LES::Smagorinsky>();
auto x58 = parameters.template get<olb::descriptors::OMEGA>();
auto x0 = V{0.5}/x58;
auto x1 = V{0.0130945659698734}/((x58)*(x58));
auto x2 = cell[15] + cell[21] + cell[22];
auto x3 = cell[12] + cell[26];
auto x4 = x2 + x3 + cell[0] + cell[10] + cell[11] + cell[13] + cell[14] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[23] + cell[24] + cell[25] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1};
auto x5 = V{1} / (x4);
auto x6 = V{0.00462962962962963}*cell[0] + V{0.00462962962962963}*cell[10] + V{0.00462962962962963}*cell[11] + V{0.00462962962962963}*cell[12] + V{0.00462962962962963}*cell[13] + V{0.00462962962962963}*cell[14] + V{0.00462962962962963}*cell[15] + V{0.00462962962962963}*cell[16] + V{0.00462962962962963}*cell[17] + V{0.00462962962962963}*cell[18] + V{0.00462962962962963}*cell[19] + V{0.00462962962962963}*cell[1] + V{0.00462962962962963}*cell[20] + V{0.00462962962962963}*cell[21] + V{0.00462962962962963}*cell[22] + V{0.00462962962962963}*cell[23] + V{0.00462962962962963}*cell[24] + V{0.00462962962962963}*cell[25] + V{0.00462962962962963}*cell[26] + V{0.00462962962962963}*cell[2] + V{0.00462962962962963}*cell[3] + V{0.00462962962962963}*cell[4] + V{0.00462962962962963}*cell[5] + V{0.00462962962962963}*cell[6] + V{0.00462962962962963}*cell[7] + V{0.00462962962962963}*cell[8] + V{0.00462962962962963}*cell[9] + V{0.00462962962962963};
auto x7 = V{3}*cell[10];
auto x8 = -V{3}*cell[23];
auto x9 = V{3}*cell[20];
auto x10 = V{3}*cell[22];
auto x11 = V{3}*cell[24];
auto x12 = V{3}*cell[7];
auto x13 = V{3}*cell[9];
auto x14 = V{3}*cell[11];
auto x15 = V{3}*cell[12];
auto x16 = V{3}*cell[25];
auto x17 = x15 - x16 - V{3}*cell[19] + V{3}*cell[6];
auto x18 = V{3}*cell[26];
auto x19 = V{3}*cell[13];
auto x20 = x18 - x19 - V{3}*cell[21] + V{3}*cell[8];
auto x21 = x5*(x10 + x11 - x12 - x13 - x14 + x17 + x20 + x7 + x8 + x9 - V{3}*cell[16] + V{3}*cell[3]);
auto x22 = V{1} / ((x4)*(x4));
auto x23 = V{4.5}*x22;
auto x24 = -cell[13];
auto x25 = -cell[25];
auto x26 = -cell[14];
auto x27 = cell[11] - cell[24];
auto x28 = x26 + x27 + cell[1];
auto x29 = -V{2}*cell[19] + V{2}*cell[6];
auto x30 = -cell[16];
auto x31 = x30 + cell[3];
auto x32 = x31 - V{2}*cell[21] + V{2}*cell[8];
auto x33 = -V{2}*cell[17] + V{2}*cell[4];
auto x34 = -cell[15];
auto x35 = x34 + cell[2];
auto x36 = x33 + x35;
auto x37 = x24 + x25 + x28 + x29 + x3 + x32 + x36 + V{3}*cell[10] - V{3}*cell[23];
auto x38 = V{3}*cell[18];
auto x39 = V{3}*cell[5];
auto x40 = -x11 + x14 + x7 + x8 - V{3}*cell[17] + V{3}*cell[4];
auto x41 = x5*(-x10 + x13 - x15 + x16 + x20 + x38 - x39 + x40 - V{3}*cell[15] + V{3}*cell[2]);
auto x42 = x5*(x12 + x17 - x18 + x19 - x38 + x39 + x40 - x9 - V{3}*cell[14] + V{3}*cell[1]);
auto x43 = V{1.5}*x22;
auto x44 = -cell[19];
auto x45 = x25 + x44 + cell[12] + cell[6];
auto x46 = -cell[18] + cell[5];
auto x47 = -cell[17];
auto x48 = x47 + cell[4];
auto x49 = -cell[20] + cell[7];
auto x50 = x48 + x49;
auto x51 = cell[10] - cell[23];
auto x52 = x51 + cell[13] - cell[26];
auto x53 = x28 + x45 + x46 + x50 + x52;
auto x54 = x53*x53;
auto x55 = x43*x54;
auto x56 = -cell[21];
auto x57 = x47 + x56 + cell[4] + cell[8];
auto x60 = x24 + x51 + cell[26];
auto x61 = -cell[22] + cell[9];
auto x62 = x34 + x61 + cell[2];
auto x63 = cell[18] - cell[5];
auto x64 = -cell[12] + cell[25];
auto x65 = x27 + x57 + x60 + x62 + x63 + x64;
auto x66 = x65*x65;
auto x67 = x43*x66;
auto x68 = x56 + cell[8];
auto x69 = -cell[9];
auto x70 = x30 + x69 + cell[22] + cell[3];
auto x71 = -cell[11] + cell[24];
auto x72 = cell[20] - cell[7];
auto x73 = x45 + x60 + x68 + x70 + x71 + x72;
auto x74 = x73*x73;
auto x75 = x43*x74;
auto x76 = x67 + x75 + V{-1};
auto x77 = x55 + x76;
auto x78 = x42 + x77;
auto x79 = x41 + x78;
auto x80 = x59*x59;
auto x81 = -x21;
auto x82 = -cell[3];
auto x83 = V{2}*cell[20];
auto x84 = V{2}*cell[7];
auto x85 = -x83 + x84;
auto x86 = V{2}*cell[22];
auto x87 = V{2}*cell[9];
auto x88 = -x86 + x87;
auto x89 = x26 + cell[1];
auto x90 = x52 + x89;
auto x91 = -x36 - x64 - x82 - x85 - x88 - x90 - V{3}*cell[11] - cell[16] + V{3}*cell[24];
auto x92 = -x23*x91*x91;
auto x93 = -x41;
auto x94 = V{2}*cell[18];
auto x95 = V{2}*cell[5];
auto x96 = -x94 + x95 - cell[2];
auto x97 = -x29 - x31 - x71 - x86 + x87 - x90 - x96 - V{3}*cell[12] - cell[15] + V{3}*cell[25];
auto x98 = x23*(x97*x97);
auto x99 = x21 + x78;
auto x100 = -x42;
auto x101 = -x32 - x35 - x51 - x64 - x71 - x83 + x84 - x94 + x95 + V{3}*cell[13] - cell[14] + cell[1] - V{3}*cell[26];
auto x102 = x23*(x101*x101);
auto x103 = -V{1.5}*x22*x66;
auto x104 = -V{1.5}*x22*x74 + V{1};
auto x105 = x103 + x104;
auto x106 = -V{1.5}*x22*x54;
auto x107 = x106 + x41;
auto x108 = x105 + x107 + x21;
auto x109 = x41 + x77;
auto x110 = x109 + x21;
auto x111 = x105 + x42;
auto x112 = x106 + x21;
auto x113 = x111 + x112;
auto x114 = x21 + x77;
auto x115 = x100 + x114;
auto x116 = -x37;
auto x117 = x107 + x111;
auto x118 = V{0.0185185185185185}*cell[0] + V{0.0185185185185185}*cell[10] + V{0.0185185185185185}*cell[11] + V{0.0185185185185185}*cell[12] + V{0.0185185185185185}*cell[13] + V{0.0185185185185185}*cell[14] + V{0.0185185185185185}*cell[15] + V{0.0185185185185185}*cell[16] + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[1] + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[23] + V{0.0185185185185185}*cell[24] + V{0.0185185185185185}*cell[25] + V{0.0185185185185185}*cell[26] + V{0.0185185185185185}*cell[2] + V{0.0185185185185185}*cell[3] + V{0.0185185185185185}*cell[4] + V{0.0185185185185185}*cell[5] + V{0.0185185185185185}*cell[6] + V{0.0185185185185185}*cell[7] + V{0.0185185185185185}*cell[8] + V{0.0185185185185185}*cell[9] + V{0.0185185185185185};
auto x119 = V{2}*cell[11] - V{2}*cell[24];
auto x120 = -V{2}*cell[23];
auto x121 = V{2}*cell[10];
auto x122 = x120 + x121 + x89;
auto x123 = x44 + cell[6];
auto x124 = x123 + x49;
auto x125 = x119 + x122 + x124 + x33 + x62 + x68;
auto x126 = V{2}*cell[25];
auto x127 = V{2}*cell[12];
auto x128 = -x126 + x127;
auto x129 = x122 + x128 + x29 + x46 + x57 + x70;
auto x130 = V{2}*cell[26];
auto x131 = V{2}*cell[13];
auto x132 = -x130 + x131 + x89 - cell[8];
auto x133 = -x124 - x128 - x132 - x2 - x69 - x96;
auto x134 = -x23*x133*x133;
auto x135 = x119 + x82 + cell[16];
auto x136 = -x132 - x135 - x46 - x48 - x61 - x85 - cell[21];
auto x137 = -x23*x136*x136;
auto x138 = x35 + x63;
auto x139 = x120 + x121 + x123 + x130 - x131 + x138 + x32 + x48 + x72;
auto x140 = -x126 + x127 - x135 - x138 - x50 - x88 - cell[19] + cell[6];
auto x141 = -x23*x140*x140;
auto x142 = -x125;
auto x143 = -x129;
auto x144 = -x139;
auto x145 = V{0.0740740740740741}*cell[0] + V{0.0740740740740741}*cell[10] + V{0.0740740740740741}*cell[11] + V{0.0740740740740741}*cell[12] + V{0.0740740740740741}*cell[13] + V{0.0740740740740741}*cell[14] + V{0.0740740740740741}*cell[15] + V{0.0740740740740741}*cell[16] + V{0.0740740740740741}*cell[17] + V{0.0740740740740741}*cell[18] + V{0.0740740740740741}*cell[19] + V{0.0740740740740741}*cell[1] + V{0.0740740740740741}*cell[20] + V{0.0740740740740741}*cell[21] + V{0.0740740740740741}*cell[22] + V{0.0740740740740741}*cell[23] + V{0.0740740740740741}*cell[24] + V{0.0740740740740741}*cell[25] + V{0.0740740740740741}*cell[26] + V{0.0740740740740741}*cell[2] + V{0.0740740740740741}*cell[3] + V{0.0740740740740741}*cell[4] + V{0.0740740740740741}*cell[5] + V{0.0740740740740741}*cell[6] + V{0.0740740740740741}*cell[7] + V{0.0740740740740741}*cell[8] + V{0.0740740740740741}*cell[9] + V{0.0740740740740741};
auto x146 = V{3}*x22;
auto x147 = x146*x54;
auto x148 = x146*x66;
auto x149 = x55 + V{-1};
auto x150 = x146*x74;
return V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x77*(V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296}) + cell[0] + V{0.296296296296296}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x6*(x93 - x98 + x99) + cell[25] + V{0.00462962962962963}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x6*(x79 + x81 + x92) + cell[24] + V{0.00462962962962963}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x6*(x21 - x23*x37*x37 + x79) + cell[23] + V{0.00462962962962963}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(-x6*(x117 + x21 + x23*(x116*x116)) + cell[10] + V{0.00462962962962963}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x6*(x115 + x92 + x93) + cell[11] + V{0.00462962962962963}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x6*(-x113 - x93 - x98) + cell[12] + V{0.00462962962962963}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x6*(x100 - x102 + x110) + cell[13] + V{0.00462962962962963}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x6*(-x100 - x102 - x108) + cell[26] + V{0.00462962962962963}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x145*(x149 - x150 + x21 + x67) + cell[16] + V{0.0740740740740741}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x145*(-x148 + x149 + x41 + x75) + cell[15] + V{0.0740740740740741}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x145*(-x103 - x112 - x150 + V{-1}) + cell[3] + V{0.0740740740740741}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x145*(-x147 + x42 + x76) + cell[14] + V{0.0740740740740741}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x145*(-x104 - x107 - x148) + cell[2] + V{0.0740740740740741}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x145*(-x111 - x147) + cell[1] + V{0.0740740740740741}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(x137 + x78 + x81) + cell[20] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(x134 + x78 + x93) + cell[18] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(x114 + x141 + x93) + cell[9] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(x109 + x141 + x81) + cell[22] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(x100 + x109 + x134) + cell[5] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(-x23*x129*x129 + x99) + cell[19] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(-x23*x125*x125 + x79) + cell[17] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(-x118*(x117 + x23*(x142*x142)) + cell[4] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(x115 + x137) + cell[7] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(-x118*(x113 + x23*(x143*x143)) + cell[6] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(x118*(x110 - x23*x139*x139) + cell[21] + V{0.0185185185185185}))) + V{0.037037037037037}/(x0 + V{4.369426621423}*util::sqrt(x1 + x5*x80*util::fabs(-x118*(x108 + x23*(x144*x144)) + cell[8] + V{0.0185185185185185})));
}
 
};
 
 
}
 
}
 
}
 
#endif
 
#endif