olb::dynamics::CSE< dynamics::Tuple< T, descriptors::D3Q19< FIELDS... >, momenta::Tuple< momenta::BulkDensity, momenta::MovingPorousMomentumCombination< momenta::BulkMomentum >, momenta::BulkStress, momenta::DefineToNEq >, equilibria::ThirdOrder, collision::TrackAverageVelocity< collision::ParameterFromCell< collision::HYBRID, collision::LocalSmagorinskyEffectiveOmega< collision::HRR > > >, dynamics::DefaultCombination > > Struct Template Reference

#include <c1e74e09d2251ce2fe7cbe6d512ddb6cb979667d135ae2a6fe0ffcabf87b7289.cse.h>

Collaboration diagram for olb::dynamics::CSE< dynamics::Tuple< T, descriptors::D3Q19< FIELDS... >, momenta::Tuple< momenta::BulkDensity, momenta::MovingPorousMomentumCombination< momenta::BulkMomentum >, momenta::BulkStress, momenta::DefineToNEq >, equilibria::ThirdOrder, collision::TrackAverageVelocity< collision::ParameterFromCell< collision::HYBRID, collision::LocalSmagorinskyEffectiveOmega< collision::HRR > > >, dynamics::DefaultCombination > >:

Public Member Functions
template<concepts::Cell CELL, concepts::Parameters PARAMETERS, concepts::BaseType V = typename CELL::value_t>
CellStatistic< V >	collide (CELL &cell, PARAMETERS &parameters) any_platform

Detailed Description

template<typename T, typename... FIELDS>
struct olb::dynamics::CSE< dynamics::Tuple< T, descriptors::D3Q19< FIELDS... >, momenta::Tuple< momenta::BulkDensity, momenta::MovingPorousMomentumCombination< momenta::BulkMomentum >, momenta::BulkStress, momenta::DefineToNEq >, equilibria::ThirdOrder, collision::TrackAverageVelocity< collision::ParameterFromCell< collision::HYBRID, collision::LocalSmagorinskyEffectiveOmega< collision::HRR > > >, dynamics::DefaultCombination > >

Definition at line 38 of file c1e74e09d2251ce2fe7cbe6d512ddb6cb979667d135ae2a6fe0ffcabf87b7289.cse.h.

Member Function Documentation

collide()

template<typename T , typename... FIELDS>

template<concepts::Cell CELL, concepts::Parameters PARAMETERS, concepts::BaseType V = typename CELL::value_t>

CellStatistic< V > olb::dynamics::CSE< dynamics::Tuple< T, descriptors::D3Q19< FIELDS... >, momenta::Tuple< momenta::BulkDensity, momenta::MovingPorousMomentumCombination< momenta::BulkMomentum >, momenta::BulkStress, momenta::DefineToNEq >, equilibria::ThirdOrder, collision::TrackAverageVelocity< collision::ParameterFromCell< collision::HYBRID, collision::LocalSmagorinskyEffectiveOmega< collision::HRR > > >, dynamics::DefaultCombination > >::collide ( CELL & cell, PARAMETERS & parameters )

inline

Definition at line 40 of file c1e74e09d2251ce2fe7cbe6d512ddb6cb979667d135ae2a6fe0ffcabf87b7289.cse.h.

                                                                          {
auto x21 = cell.template getFieldComponent<descriptors::AVERAGE_VELOCITY>(1);
auto x20 = cell.template getFieldComponent<descriptors::AVERAGE_VELOCITY>(0);
auto x31 = cell.template getFieldComponent<descriptors::VELOCITY>(0);
auto x36 = cell.template getFieldComponent<descriptors::WMVELOCITY>(1);
auto x24 = cell.template getFieldComponent<descriptors::POROSITY>(0);
auto x38 = parameters.template get<descriptors::OMEGA>();
auto x35 = cell.template getFieldComponent<descriptors::WMVELOCITY>(0);
auto x29 = cell.template getFieldComponent<descriptors::TENSOR>(4);
auto x22 = cell.template getFieldComponent<descriptors::AVERAGE_VELOCITY>(2);
auto x27 = cell.template getFieldComponent<descriptors::TENSOR>(2);
auto x32 = cell.template getFieldComponent<descriptors::VELOCITY>(1);
auto x25 = cell.template getFieldComponent<descriptors::TENSOR>(0);
auto x37 = cell.template getFieldComponent<descriptors::WMVELOCITY>(2);
auto x33 = cell.template getFieldComponent<descriptors::VELOCITY>(2);
auto x40 = parameters.template get<collision::LES::SMAGORINSKY>();
auto x26 = cell.template getFieldComponent<descriptors::TENSOR>(1);
auto x28 = cell.template getFieldComponent<descriptors::TENSOR>(3);
auto x34 = cell.template getFieldComponent<descriptors::WMPOROSITY>(0);
auto x30 = cell.template getFieldComponent<descriptors::TENSOR>(5);
auto x19 = cell.template getFieldComponent<collision::HYBRID>(0);
auto x41 = parameters.template get<descriptors::LATTICE_TIME>();
auto x23 = V{0.5}/x38;
auto x39 = V{0.0277777691819762}/((x38)*(x38));
auto x42 = cell[12] + cell[17] + cell[7];
auto x43 = cell[11] + cell[13] + cell[18];
auto x44 = cell[10] + cell[14] + cell[16];
auto x45 = cell[0] + cell[15] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + cell[9] + x42 + x43 + x44;
auto x46 = x45 + V{1};
auto x47 = V{1} / (x46);
auto x48 = x40*x40;
auto x49 = x24 + V{-1};
auto x50 = -x49;
auto x51 = -cell[8];
auto x52 = cell[9] + x51;
auto x53 = cell[15] - cell[6];
auto x54 = V{1}*x24*x47;
auto x55 = x54*(-cell[16] - cell[18] - cell[3] + x42 + x52 + x53);
auto x56 = x33*x50 + x55;
auto x57 = x34*x56;
auto x58 = x34 + V{-1};
auto x59 = -x58;
auto x60 = x37*x59;
auto x61 = x57 + x60;
auto x62 = x61*x61;
auto x63 = x46*x62;
auto x64 = V{0.333333333333333}*cell[13];
auto x65 = V{0.333333333333333}*cell[14];
auto x66 = V{0.333333333333333}*cell[4];
auto x67 = V{0.333333333333333}*cell[5];
auto x68 = V{0.666666666666667}*cell[12];
auto x69 = V{0.666666666666667}*cell[3];
auto x70 = V{0.333333333333333}*cell[0];
auto x71 = V{0.333333333333333}*cell[10];
auto x72 = V{0.333333333333333}*cell[1];
auto x73 = V{0.666666666666667}*cell[17];
auto x74 = V{0.666666666666667}*cell[18];
auto x75 = V{0.666666666666667}*cell[8];
auto x76 = V{0.666666666666667}*cell[9];
auto x77 = x70 + x71 + x72 - x73 - x74 - x75 - x76;
auto x78 = V{0.333333333333333}*cell[11];
auto x79 = V{0.333333333333333}*cell[2];
auto x80 = V{0.666666666666667}*cell[15];
auto x81 = V{0.666666666666667}*cell[16];
auto x82 = V{0.666666666666667}*cell[6];
auto x83 = V{0.666666666666667}*cell[7];
auto x84 = x78 + x79 - x80 - x81 - x82 - x83;
auto x85 = x64 + x65 + x66 + x67 - x68 - x69 + x77 + x84;
auto x86 = x63 + x85;
auto x87 = -cell[4];
auto x88 = cell[5] + x87;
auto x89 = x54*(-cell[14] + cell[17] - cell[2] - cell[9] + x43 + x51 + x88);
auto x90 = x32*x50 + x89;
auto x91 = x34*x90;
auto x92 = x36*x59;
auto x93 = x91 + x92;
auto x94 = x93*x93;
auto x95 = x46*x94;
auto x96 = V{0.333333333333333}*cell[15];
auto x97 = V{0.333333333333333}*cell[16];
auto x98 = V{0.333333333333333}*cell[6];
auto x99 = V{0.333333333333333}*cell[7];
auto x100 = V{0.666666666666667}*cell[11];
auto x101 = V{0.666666666666667}*cell[2];
auto x102 = V{0.333333333333333}*cell[12];
auto x103 = V{0.333333333333333}*cell[3];
auto x104 = V{0.666666666666667}*cell[13];
auto x105 = V{0.666666666666667}*cell[14];
auto x106 = V{0.666666666666667}*cell[4];
auto x107 = V{0.666666666666667}*cell[5];
auto x108 = x102 + x103 - x104 - x105 - x106 - x107;
auto x109 = -x100 - x101 + x108 + x77 + x96 + x97 + x98 + x99;
auto x110 = x109 + x95;
auto x111 = x54*(cell[13] - cell[1] - cell[5] - cell[7] + x44 + x53 + x87);
auto x112 = x111 + x31*x50;
auto x113 = x112*x34;
auto x114 = x35*x59;
auto x115 = x113 + x114;
auto x116 = x115*x115;
auto x117 = x116*x46;
auto x118 = V{0.333333333333333}*cell[17];
auto x119 = V{0.333333333333333}*cell[18];
auto x120 = V{0.333333333333333}*cell[8];
auto x121 = V{0.333333333333333}*cell[9];
auto x122 = V{0.666666666666667}*cell[10];
auto x123 = V{0.666666666666667}*cell[1];
auto x124 = x108 + x118 + x119 + x120 + x121 - x122 - x123 + x70 + x84;
auto x125 = x117 + x124;
auto x126 = x115*x46;
auto x127 = -V{1}*cell[15] + V{1}*cell[16] - V{1}*cell[6] + V{1}*cell[7];
auto x128 = x126*x61 + x127;
auto x129 = x126*x93;
auto x130 = -cell[13] + cell[14] + x88;
auto x131 = x129 + x130;
auto x132 = -V{1}*cell[13] + V{1}*cell[14] - V{1}*cell[4] + V{1}*cell[5];
auto x133 = x129 + x132;
auto x134 = x46*x61*x93;
auto x135 = -cell[17] + cell[18] + x52;
auto x136 = x134 + x135;
auto x137 = -V{1}*cell[17] + V{1}*cell[18] - V{1}*cell[8] + V{1}*cell[9];
auto x138 = x134 + x137;
auto x139 = x23 + V{3.00000046417339}*util::sqrt(x39 + x47*x48*util::sqrt(x131*x133 + x136*x138 + V{0.5}*(x110*x110) + V{0.5}*(x125*x125) + V{1}*(x128*x128) + V{0.5}*(x86*x86)));
auto x140 = V{1} - 1/x139;
auto x141 = V{0.5}*x19;
auto x142 = -x70;
auto x143 = -x102 - x103 + x104 + x105 + x106 + x107 + x142;
auto x144 = -x78 - x79 + x80 + x81 + x82 + x83;
auto x145 = -x117 - x118 - x119 - x120 - x121 + x122 + x123 + x143 + x144;
auto x146 = -x71 - x72 + x73 + x74 + x75 + x76;
auto x147 = x100 + x101 + x143 + x146 - x95 - x96 - x97 - x98 - x99;
auto x148 = x142 + x144 + x146 - x63 - x64 - x65 - x66 - x67 + x68 + x69;
auto x149 = x25*x46;
auto x150 = x19 + V{-1};
auto x151 = -x150;
auto x152 = V{0.333333333333333}*x151;
auto x153 = -x128;
auto x154 = -x133;
auto x155 = -x138;
auto x156 = x23 + V{3.00000046417339}*util::sqrt(x39 + x47*x48*util::sqrt(-x131*x154 - x136*x155 + V{0.5}*(x145*x145) + V{0.5}*(x147*x147) + V{0.5}*(x148*x148) + V{1}*(x153*x153)));
auto x157 = x152*x46;
auto x158 = V{1.5}*x62;
auto x159 = V{1.5}*x116;
auto x160 = V{1.5}*x94;
auto x161 = x159 + x160 + V{-1};
auto x162 = x158 + x161;
auto x163 = V{1}*x140*(x141*x145 + x141*x147 + x141*x148 - x149*x152*x156 - x156*x157*x28 - x156*x157*x30) + x162*(x102 + x103 + x118 + x119 + x120 + x121 + x64 + x65 + x66 + x67 + x70 + x71 + x72 + x78 + x79 + x96 + x97 + x98 + x99 + V{0.333333333333333});
auto x164 = x33*x49;
auto x165 = -x164 + x55;
auto x166 = x165*x34;
auto x167 = x37*x58;
auto x168 = x166 - x167;
auto x169 = x168*x168;
auto x170 = x169*x46 + x85;
auto x171 = -x32*x49;
auto x172 = x171 + x89;
auto x173 = x172*x34;
auto x174 = x36*x58;
auto x175 = -x174;
auto x176 = x173 + x175;
auto x177 = x176*x176;
auto x178 = x109 + x177*x46;
auto x179 = x31*x49;
auto x180 = x111 - x179;
auto x181 = x180*x34;
auto x182 = x35*x58;
auto x183 = x181 - x182;
auto x184 = x183*x183;
auto x185 = x124 + x184*x46;
auto x186 = x183*x46;
auto x187 = x127 + x168*x186;
auto x188 = x176*x186;
auto x189 = x168*x176*x46;
auto x190 = x23 + V{3.00000046417339}*util::sqrt(x39 + x47*x48*util::sqrt((x130 + x188)*(x132 + x188) + (x135 + x189)*(x137 + x189) + V{0.5}*(x170*x170) + V{0.5}*(x178*x178) + V{0.5}*(x185*x185) + V{1}*(x187*x187)));
auto x191 = V{1} / (x190);
auto x192 = V{1} - x191;
auto x193 = V{0.5}*x180*x34 - V{0.5}*x35*x58;
auto x194 = x19*x86;
auto x195 = x150*x46;
auto x196 = V{0.666666666666667}*x195;
auto x197 = x139*x196*x30;
auto x198 = x194 - x197;
auto x199 = x110*x19;
auto x200 = x139*x196*x28;
auto x201 = x199 - x200;
auto x202 = V{1}*x172*x34 - V{1}*x36*x58;
auto x203 = x133*x19;
auto x204 = x139*x196*x26;
auto x205 = x203 - x204;
auto x206 = V{1}*x165*x34 - V{1}*x37*x58;
auto x207 = x128*x19;
auto x208 = x139*x196*x27;
auto x209 = x207 - x208;
auto x210 = V{0.166666666666667}*x19;
auto x211 = V{0.0555555555555556}*x195;
auto x212 = x211*x30;
auto x213 = -V{0.0833333333333333}*x170*x19 + x190*x212;
auto x214 = x211*x28;
auto x215 = -V{0.0833333333333333}*x178*x19 + x190*x214;
auto x216 = 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 x217 = V{3}*x184;
auto x218 = V{1.5}*x177;
auto x219 = V{1.5}*x169;
auto x220 = -x219;
auto x221 = -x218 + x220 + V{1};
auto x222 = V{6.000003}*x180*x34 - V{6.000003}*x35*x58;
auto x223 = V{2.999997}*x172*x34 - V{2.999997}*x36*x58;
auto x224 = x177*x222;
auto x225 = x184*x223;
auto x226 = V{3}*x182;
auto x227 = V{3}*x181;
auto x228 = x226 - x227;
auto x229 = x224 + x225 + x228;
auto x230 = x169*x222 + x169*x223 + x229;
auto x231 = V{1}*x192*(V{0.111111111111111}*x150*x190*x25*x46 - x185*x210 - x193*x198 - x193*x201 - x202*x205 - x206*x209 - x213 - x215) + x216*(x217 + x221 + x230);
auto x232 = V{0.5}*x172*x34 - V{0.5}*x36*x58;
auto x233 = x125*x19;
auto x234 = x149*x150;
auto x235 = V{0.666666666666667}*x139*x234;
auto x236 = x233 - x235;
auto x237 = V{1}*x180*x34 - V{1}*x35*x58;
auto x238 = x138*x19;
auto x239 = x139*x196*x29;
auto x240 = x238 - x239;
auto x241 = V{0.0555555555555556}*x234;
auto x242 = -V{0.0833333333333333}*x185*x19 + x190*x241;
auto x243 = V{1.5}*x184;
auto x244 = -x243;
auto x245 = V{6.000003}*x172*x34 - V{6.000003}*x36*x58;
auto x246 = V{2.999997}*x180*x34 - V{2.999997}*x35*x58;
auto x247 = x184*x245;
auto x248 = x177*x246;
auto x249 = V{3}*x174;
auto x250 = V{3}*x173;
auto x251 = x249 - x250;
auto x252 = x247 + x248 + x251;
auto x253 = x169*x245 + x169*x246 + x252;
auto x254 = V{9}*x34*x56 + V{9}*x37*x59;
auto x255 = x116*x254;
auto x256 = x254*x94;
auto x257 = x161 - V{3}*x62;
auto x258 = V{3}*x57;
auto x259 = V{3}*x60;
auto x260 = x258 + x259;
auto x261 = x210*x86;
auto x262 = V{0.111111111111111}*x195;
auto x263 = x139*x262*x30;
auto x264 = V{0.0833333333333333}*x19;
auto x265 = x110*x264;
auto x266 = x139*x214;
auto x267 = -x266;
auto x268 = x265 + x267;
auto x269 = x125*x264;
auto x270 = x139*x241;
auto x271 = -x270;
auto x272 = x269 + x271;
auto x273 = V{0.5}*x165*x34 - V{0.5}*x37*x58;
auto x274 = -x199 + x200;
auto x275 = -x233 + x235;
auto x276 = -x207 + x208;
auto x277 = -x238 + x239;
auto x278 = x202*x277 + x237*x276 + x273*x274 + x273*x275;
auto x279 = -V{1}*x140*(-x261 + x263 + x268 + x272 + x278) + x216*(-x255 - x256 + x257 + x260);
auto x280 = 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 x281 = x115 + x93;
auto x282 = -V{4.5}*x281*x281;
auto x283 = V{3}*x113;
auto x284 = V{3}*x114;
auto x285 = x162 + x283 + x284;
auto x286 = V{3}*x91;
auto x287 = V{3}*x92;
auto x288 = x286 + x287;
auto x289 = x280*(x116*(V{18}*x34*x90 + V{18}*x36*x59) + x282 + x285 + x288 - x62*(V{9}*x112*x34 + V{9}*x35*x59) - x62*(V{9}*x34*x90 + V{9}*x36*x59) + x94*(V{18}*x112*x34 + V{18}*x35*x59));
auto x290 = V{2.49999999985601e-07}*x172*x34 - V{2.49999999985601e-07}*x36*x58;
auto x291 = -x194 + x197;
auto x292 = x290*x291;
auto x293 = V{4.99999999971202e-07}*x165*x34 - V{4.99999999971202e-07}*x37*x58;
auto x294 = x277*x293;
auto x295 = V{0.25}*x203;
auto x296 = -x295;
auto x297 = V{0.25000025}*x172*x34 - V{0.25000025}*x36*x58;
auto x298 = x275*x297;
auto x299 = -x298;
auto x300 = V{0.5000005}*x180*x34 - V{0.5000005}*x35*x58;
auto x301 = -x203 + x204;
auto x302 = x300*x301;
auto x303 = -x302;
auto x304 = V{0.166666666666667}*x26;
auto x305 = x139*x195*x304;
auto x306 = x292 + x294 + x296 + x299 + x303 + x305;
auto x307 = V{2.49999999985601e-07}*x180*x34 - V{2.49999999985601e-07}*x35*x58;
auto x308 = x291*x307;
auto x309 = x276*x293;
auto x310 = V{0.25000025}*x180*x34 - V{0.25000025}*x35*x58;
auto x311 = x274*x310;
auto x312 = V{0.5000005}*x172*x34 - V{0.5000005}*x36*x58;
auto x313 = x301*x312;
auto x314 = x308 + x309 - x311 - x313;
auto x315 = V{0.0416666666666667}*x19;
auto x316 = x315*x86;
auto x317 = V{0.0277777777777778}*x30;
auto x318 = x139*x195*x317;
auto x319 = V{0.0833333333333333}*x19;
auto x320 = x125*x319;
auto x321 = x270 - x320;
auto x322 = x110*x319;
auto x323 = x266 - x322;
auto x324 = x316 - x318 + x321 + x323;
auto x325 = V{1}*x140*(x306 + x314 + x324);
auto x326 = x289 - x325;
auto x327 = V{0.25000025}*x112*x34 + V{0.25000025}*x35*x59;
auto x328 = V{0.666666666666667}*x151;
auto x329 = x328*x46;
auto x330 = x147*x19 - x156*x28*x329;
auto x331 = x327*x330;
auto x332 = V{0.5000005}*x34*x90 + V{0.5000005}*x36*x59;
auto x333 = x154*x19;
auto x334 = -x156*x26*x329 + x333;
auto x335 = x332*x334;
auto x336 = V{2.49999999985601e-07}*x34*x90 + V{2.49999999985601e-07}*x36*x59;
auto x337 = x148*x19 - x156*x30*x329;
auto x338 = x336*x337;
auto x339 = V{4.99999999971202e-07}*x34*x56 + V{4.99999999971202e-07}*x37*x59;
auto x340 = x155*x19;
auto x341 = -x156*x29*x329 + x340;
auto x342 = x339*x341;
auto x343 = V{0.25000025}*x34*x90 + V{0.25000025}*x36*x59;
auto x344 = x145*x19 - x149*x156*x328;
auto x345 = x343*x344;
auto x346 = V{0.5000005}*x112*x34 + V{0.5000005}*x35*x59;
auto x347 = x334*x346;
auto x348 = V{2.49999999985601e-07}*x112*x34 + V{2.49999999985601e-07}*x35*x59;
auto x349 = x337*x348;
auto x350 = x153*x19;
auto x351 = -x156*x27*x329 + x350;
auto x352 = x339*x351;
auto x353 = x151*x46;
auto x354 = V{0.0555555555555556}*x151;
auto x355 = x149*x156*x354;
auto x356 = -x145*x319 + x355;
auto x357 = x354*x46;
auto x358 = x156*x28*x357;
auto x359 = -x147*x319 + x358;
auto x360 = x148*x315 - x156*x304*x353 - x156*x317*x353 + V{0.25}*x333 + x356 + x359;
auto x361 = x115 - x91 - x92;
auto x362 = -x361;
auto x363 = x62*(V{3.000006}*x34*x90 + V{3.000006}*x36*x59);
auto x364 = x94*(V{6.000012}*x112*x34 + V{6.000012}*x35*x59);
auto x365 = x62*(V{3.000006}*x112*x34 + V{3.000006}*x35*x59);
auto x366 = x116*(V{6.000012}*x34*x90 + V{6.000012}*x36*x59);
auto x367 = -x286 - x287;
auto x368 = V{1}*x140*(x331 + x335 + x338 + x342 - x345 - x347 - x349 - x352 + x360) + x280*(x285 + x363 + x364 - x365 - x366 + x367 - V{4.5}*x362*x362);
auto x369 = x115 + x61;
auto x370 = -V{4.5}*x369*x369;
auto x371 = V{9.000009}*x34*x56 + V{9.000009}*x37*x59;
auto x372 = x116*x371;
auto x373 = V{8.99999999948164e-06}*x34*x56 + V{8.99999999948164e-06}*x37*x59;
auto x374 = x373*x94;
auto x375 = x260 + x372 - x374;
auto x376 = x62*(V{5.999994}*x34*x90 + V{5.999994}*x36*x59);
auto x377 = x62*(V{12.000006}*x112*x34 + V{12.000006}*x35*x59);
auto x378 = V{6.000003}*x112*x34 + V{6.000003}*x35*x59;
auto x379 = x378*x94;
auto x380 = V{2.999997}*x34*x90 + V{2.999997}*x36*x59;
auto x381 = x116*x380;
auto x382 = x285 + x376 + x377 - x379 - x381;
auto x383 = V{2.49999999985601e-07}*x165*x34 - V{2.49999999985601e-07}*x37*x58;
auto x384 = x274*x383;
auto x385 = V{4.99999999971202e-07}*x172*x34 - V{4.99999999971202e-07}*x36*x58;
auto x386 = x277*x385;
auto x387 = V{0.25}*x207;
auto x388 = -x387;
auto x389 = V{0.25000025}*x165*x34 - V{0.25000025}*x37*x58;
auto x390 = x275*x389;
auto x391 = -x390;
auto x392 = x276*x300;
auto x393 = -x392;
auto x394 = V{0.166666666666667}*x27;
auto x395 = x139*x195*x394;
auto x396 = x384 + x386 + x388 + x391 + x393 + x395;
auto x397 = x274*x307;
auto x398 = x301*x385;
auto x399 = x291*x310;
auto x400 = V{0.5000005}*x165*x34 - V{0.5000005}*x37*x58;
auto x401 = x276*x400;
auto x402 = x397 + x398 - x399 - x401;
auto x403 = x110*x315;
auto x404 = V{0.0277777777777778}*x28;
auto x405 = x139*x195*x404;
auto x406 = x139*x212;
auto x407 = x319*x86;
auto x408 = x406 - x407;
auto x409 = x321 + x403 - x405 + x408;
auto x410 = -V{1}*x140*(x396 + x402 + x409) + x280*(x370 + x375 + x382);
auto x411 = x327*x337;
auto x412 = V{0.5000005}*x34*x56 + V{0.5000005}*x37*x59;
auto x413 = x351*x412;
auto x414 = V{2.49999999985601e-07}*x34*x56 + V{2.49999999985601e-07}*x37*x59;
auto x415 = x330*x414;
auto x416 = V{4.99999999971202e-07}*x34*x90 + V{4.99999999971202e-07}*x36*x59;
auto x417 = x341*x416;
auto x418 = V{0.25000025}*x34*x56 + V{0.25000025}*x37*x59;
auto x419 = x344*x418;
auto x420 = x346*x351;
auto x421 = x330*x348;
auto x422 = x334*x416;
auto x423 = x156*x30*x357;
auto x424 = -x148*x319 + x423;
auto x425 = x147*x315 - x156*x353*x394 - x156*x353*x404 + V{0.25}*x350 + x356 + x424;
auto x426 = -x34*x56 - x37*x59;
auto x427 = x115 + x426;
auto x428 = -x427;
auto x429 = -x258 - x259;
auto x430 = V{1}*x140*(x411 + x413 + x415 + x417 - x419 - x420 - x421 - x422 + x425) + x280*(-x372 + x374 + x382 + x429 - V{4.5}*x428*x428);
auto x431 = x61 + x93;
auto x432 = -V{4.5}*x431*x431;
auto x433 = x371*x94;
auto x434 = x116*x373;
auto x435 = x260 + x433 - x434;
auto x436 = x62*(V{5.999994}*x112*x34 + V{5.999994}*x35*x59);
auto x437 = x62*(V{12.000006}*x34*x90 + V{12.000006}*x36*x59);
auto x438 = V{6.000003}*x34*x90 + V{6.000003}*x36*x59;
auto x439 = x116*x438;
auto x440 = V{2.999997}*x112*x34 + V{2.999997}*x35*x59;
auto x441 = x440*x94;
auto x442 = x162 + x288;
auto x443 = x436 + x437 - x439 - x441 + x442;
auto x444 = x280*(x432 + x435 + x443);
auto x445 = x125*x315;
auto x446 = V{0.25}*x238;
auto x447 = -x446;
auto x448 = V{0.166666666666667}*x29;
auto x449 = x139*x195*x448;
auto x450 = V{0.0277777777777778}*x139*x234;
auto x451 = x323 + x408 + x445 + x447 + x449 - x450;
auto x452 = x275*x290;
auto x453 = V{4.99999999971202e-07}*x180*x34 - V{4.99999999971202e-07}*x35*x58;
auto x454 = x301*x453;
auto x455 = x291*x297;
auto x456 = x277*x400;
auto x457 = x452 + x454 - x455 - x456;
auto x458 = x275*x383;
auto x459 = x276*x453;
auto x460 = x274*x389;
auto x461 = x277*x312;
auto x462 = x458 + x459 - x460 - x461;
auto x463 = x457 + x462;
auto x464 = V{1}*x140*(x451 + x463);
auto x465 = x444 - x464;
auto x466 = x337*x343;
auto x467 = x341*x412;
auto x468 = x344*x414;
auto x469 = V{4.99999999971202e-07}*x112*x34 + V{4.99999999971202e-07}*x35*x59;
auto x470 = x351*x469;
auto x471 = x330*x418;
auto x472 = x332*x341;
auto x473 = x336*x344;
auto x474 = x334*x469;
auto x475 = x149*x151;
auto x476 = x145*x315 - x156*x353*x448 - V{0.0277777777777778}*x156*x475 + V{0.25}*x340 + x359 + x424;
auto x477 = V{1}*x140*(x466 + x467 + x468 + x470 - x471 - x472 - x473 - x474 + x476);
auto x478 = x426 + x93;
auto x479 = -x478;
auto x480 = x280*(x429 - x433 + x434 + x443 - V{4.5}*x479*x479);
auto x481 = x477 + x480;
auto x482 = V{0.5}*x112*x34 + V{0.5}*x35*x59;
auto x483 = V{1}*x34*x90 + V{1}*x36*x59;
auto x484 = V{1}*x34*x56 + V{1}*x37*x59;
auto x485 = x148*x264 - x423;
auto x486 = x147*x264 - x358;
auto x487 = x158 + V{-1};
auto x488 = -x283 - x284;
auto x489 = x379 + x381 + x488;
auto x490 = V{1}*x140*(-x145*x210 + V{0.111111111111111}*x156*x475 + x330*x482 + x334*x483 + x337*x482 + x351*x484 + x485 + x486) + x216*(-V{3}*x116 + x160 + x378*x62 + x380*x62 + x487 + x489);
auto x491 = V{0.5}*x34*x90 + V{0.5}*x36*x59;
auto x492 = V{1}*x112*x34 + V{1}*x35*x59;
auto x493 = V{0.111111111111111}*x353;
auto x494 = x145*x264 - x355;
auto x495 = x367 + x439 + x441;
auto x496 = V{1}*x140*(-x147*x210 + x156*x28*x493 + x334*x492 + x337*x491 + x341*x484 + x344*x491 + x485 + x494) + x216*(x159 + x438*x62 + x440*x62 + x487 + x495 - V{3}*x94);
auto x497 = V{0.5}*x34*x56 + V{0.5}*x37*x59;
auto x498 = V{1}*x140*(-x148*x210 + x156*x30*x493 + x330*x497 + x341*x483 + x344*x497 + x351*x492 + x486 + x494) + x216*(x255 + x256 + x257 + x429);
auto x499 = x271 + x320;
auto x500 = x267 + x322;
auto x501 = -x316 + x318 + x499 + x500;
auto x502 = x314 + x501;
auto x503 = x295 - x305;
auto x504 = x176 + x183;
auto x505 = x169*(V{9}*x180*x34 - V{9}*x35*x58);
auto x506 = x169*(V{9}*x172*x34 - V{9}*x36*x58);
auto x507 = x177*(V{18}*x180*x34 - V{18}*x35*x58);
auto x508 = x184*(V{18}*x172*x34 - V{18}*x36*x58);
auto x509 = x218 + V{-1};
auto x510 = x243 + x509;
auto x511 = x219 + x510;
auto x512 = x251 + x511;
auto x513 = x228 + x505 + x506 - x507 - x508 + x512 - V{4.5}*x504*x504;
auto x514 = V{1}*x192*(x292 + x294 + x299 + x303 + x502 + x503) + x280*x513;
auto x515 = V{1}*x140*(-x331 - x335 - x338 - x342 + x345 + x347 + x349 + x352 + x360);
auto x516 = -V{4.5}*x361*x361;
auto x517 = x280*(-x363 - x364 + x365 + x366 + x442 + x488 + x516);
auto x518 = x515 + x517;
auto x519 = -x406;
auto x520 = x407 + x519;
auto x521 = -x403 + x405 + x499 + x520;
auto x522 = x402 + x521;
auto x523 = x387 - x395;
auto x524 = x168 + x183;
auto x525 = x169*(V{5.999994}*x172*x34 - V{5.999994}*x36*x58);
auto x526 = x169*(V{12.000006}*x180*x34 - V{12.000006}*x35*x58);
auto x527 = x229 - x525 - x526;
auto x528 = V{8.99999999948164e-06}*x165*x34 - V{8.99999999948164e-06}*x37*x58;
auto x529 = x177*x528;
auto x530 = V{9.000009}*x165*x34 - V{9.000009}*x37*x58;
auto x531 = x184*x530;
auto x532 = V{3}*x167;
auto x533 = V{3}*x166;
auto x534 = -x533;
auto x535 = x532 + x534;
auto x536 = x511 + x535;
auto x537 = x529 - x531 + x536;
auto x538 = x527 + x537 - V{4.5}*x524*x524;
auto x539 = V{1}*x192*(x384 + x386 + x391 + x393 + x522 + x523) + x280*x538;
auto x540 = -V{4.5}*x427*x427;
auto x541 = V{1}*x140*(-x411 - x413 - x415 - x417 + x419 + x420 + x421 + x422 + x425) + x280*(x162 + x375 - x376 - x377 + x489 + x540);
auto x542 = -x445 + x450 + x500 + x520;
auto x543 = x446 - x449 + x542;
auto x544 = x168 + x176;
auto x545 = x184*x528;
auto x546 = x177*x530;
auto x547 = x545 - x546;
auto x548 = x169*(V{5.999994}*x180*x34 - V{5.999994}*x35*x58);
auto x549 = x169*(V{12.000006}*x172*x34 - V{12.000006}*x36*x58);
auto x550 = x252 - x548 - x549;
auto x551 = x536 + x547 + x550 - V{4.5}*x544*x544;
auto x552 = V{1}*x192*(x463 + x543) + x280*x551;
auto x553 = -V{4.5}*x478*x478;
auto x554 = V{1}*x140*(-x466 - x467 - x468 - x470 + x471 + x472 + x473 + x474 + x476) + x280*(x162 + x435 - x436 - x437 + x495 + x553);
auto x555 = V{1} / (x41);
auto x556 = x125*x210;
auto x557 = V{0.111111111111111}*x139*x234;
auto x558 = x264*x86;
auto x559 = x519 + x558;
auto x560 = x193*x274 + x193*x291 + x202*x301 + x206*x276;
auto x561 = V{1}*x140*(-x110*x210 + x139*x262*x28 + x206*x277 + x232*x275 + x232*x291 + x237*x301 + x272 + x559);
auto x562 = -x397 - x398 + x399 + x401;
auto x563 = -x384;
auto x564 = -x386;
auto x565 = x388 + x390 + x392 + x395 + x563 + x564;
auto x566 = x221 + x244;
auto x567 = x216*(x253 + x566 + V{4.5}*x94);
auto x568 = -x308 - x309 + x311 + x313;
auto x569 = -x292;
auto x570 = -x294;
auto x571 = x296 + x298 + x302 + x305 + x569 + x570;
auto x572 = -x458 - x459 + x460 + x461;
auto x573 = -x452 - x454 + x455 + x456;
auto x574 = x572 + x573;
auto x575 = -V{1}*x140*(x451 + x574) - V{1}*x140*(x324 + x568 + x571) + x280*x513 + x280*x551 + x368 + x496 + x554;
auto x576 = V{1} / (-V{1}*x140*(x409 + x562 + x565) - V{1}*x140*(x268 - x556 + x557 + x559 + x560) + x163 - x216*(V{4.5}*x116 + x230 + x566) + x279 + x280*x538 + x326 + x410 + x430 + x465 + x481 + x490 + x498 + x518 + x541 - x561 - x567 + x575 + V{2.22044604925031e-16});
auto x577 = -x265 + x266;
auto x578 = V{1}*x192*(x522 + x565);
auto x579 = -x173 + x174 + x183;
auto x580 = x169*(V{3.000006}*x180*x34 - V{3.000006}*x35*x58);
auto x581 = x184*(V{6.000012}*x172*x34 - V{6.000012}*x36*x58);
auto x582 = x169*(V{3.000006}*x172*x34 - V{3.000006}*x36*x58);
auto x583 = x177*(V{6.000012}*x180*x34 - V{6.000012}*x35*x58);
auto x584 = -x249 + x250 + x511;
auto x585 = -x166 + x167;
auto x586 = x183 + x585;
auto x587 = -x532 + x533;
auto x588 = x511 + x587;
auto x589 = -x529 + x531 + x588;
auto x590 = x280*(x527 + x589 - V{4.5}*x586*x586);
auto x591 = x501 + x568;
auto x592 = x521 + x562;
auto x593 = V{1}*x192*(x396 + x592);
auto x594 = x45 + V{1};
auto x595 = -x226 + x227;
auto x596 = -x224 - x225 + x525 + x526 + x595;
auto x597 = x280*(x537 + x540 + x596);
auto x598 = -V{1}*x192*(x390 + x392 + x523 + x563 + x564 + x592) + x539 - V{0.0277777777777778}*x594*(x370 + x589 + x596);
auto x599 = x41 + V{-1};
auto x600 = x447 + x449 + x542;
auto x601 = -x247 - x248 + x548 + x549 + x584;
auto x602 = V{9}*x165*x34 - V{9}*x37*x58;
auto x603 = x177*x602 + x184*x602 + x532 + x534;
auto x604 = -x545 + x546;
auto x605 = x176 + x585;
cell[0] = -x163 + V{-0.333333333333333};
cell[1] = x231 + V{-0.0555555555555556};
cell[2] = V{1}*x192*(V{0.111111111111111}*x150*x190*x28*x46 - x178*x210 - x198*x232 - x205*x237 - x206*x240 - x213 - x232*x236 - x242) + x216*(V{3}*x177 + x220 + x244 + x253 + V{1}) + V{-0.0555555555555556};
cell[3] = -x279 + V{-0.0555555555555556};
cell[4] = -x326 + V{-0.0277777777777778};
cell[5] = -x368 + V{-0.0277777777777778};
cell[6] = -x410 + V{-0.0277777777777778};
cell[7] = -x430 + V{-0.0277777777777778};
cell[8] = -x465 + V{-0.0277777777777778};
cell[9] = -x481 + V{-0.0277777777777778};
cell[10] = -x490 + V{-0.0555555555555556};
cell[11] = -x496 + V{-0.0555555555555556};
cell[12] = -x498 + V{-0.0555555555555556};
cell[13] = -x514 + V{-0.0277777777777778};
cell[14] = -x518 + V{-0.0277777777777778};
cell[15] = -x539 + V{-0.0277777777777778};
cell[16] = -x541 + V{-0.0277777777777778};
cell[17] = -x552 + V{-0.0277777777777778};
cell[18] = -x554 + V{-0.0277777777777778};
cell.template getFieldPointer<descriptors::AVERAGE_VELOCITY>()[0] = -x555*(x182 - x20*x599 + x34*(x179 - x24*x576*(-V{1}*x192*(x306 + x591) + V{1}*x192*(x502 + x571) - V{1}*x192*(x298 + x302 + x503 + x569 + x570 + x591) + V{1}*x192*(x406 + x556 - x557 - x558 + x560 + x577) + x216*(-x217 + x219 + x230 + x509) + x231 + x280*(x228 + x580 + x581 - x582 - x583 + x584 - V{4.5}*x579*x579) + x514 + x578 + x590 - x593 - V{0.0277777777777778}*x594*(x282 - x505 - x506 + x507 + x508 + x584 + x595) - V{0.0277777777777778}*x594*(x512 + x516 - x580 - x581 + x582 + x583 + x595) - x597 + x598 + V{-2.77555756156289e-17})));
cell.template getFieldPointer<descriptors::AVERAGE_VELOCITY>()[1] = x555*(x175 + x21*x599 + x34*(x171 + x24*x576*(-x289 + x325 - x444 + x464 - x477 - x480 - x515 - x517 + x561 + x567 + x575)));
cell.template getFieldPointer<descriptors::AVERAGE_VELOCITY>()[2] = -x555*(x167 - x22*x599 + x34*(x164 - x24*x576*(-V{1}*x192*(x543 + x574) - V{1}*x192*(x457 + x572 + x600) + V{1}*x192*(x462 + x573 + x600) + V{1}*x192*(x261 - x263 - x269 + x270 + x278 + x577) + V{1}*x192*(V{0.111111111111111}*x150*x190*x30*x46 - x170*x210 - x201*x273 - x202*x240 - x209*x237 - x215 - x236*x273 - x242) + x216*(-V{3}*x169 + x510 + x603) + x280*(x535 + x547 + x553 + x601) + x552 - x578 - x590 + x593 - V{0.0555555555555556}*x594*(-x566 - x603 - V{4.5}*x62) - V{0.0277777777777778}*x594*(x432 + x587 + x601 + x604) - V{0.0277777777777778}*x594*(x550 + x588 + x604 - V{4.5}*x605*x605) + x597 + x598)));
cell.template getFieldPointer<descriptors::OMEGA>()[0] = V{1}*x191;
return { x46, x169 + x177 + x184 };
}

References olb::util::sqrt().

Here is the call graph for this function:

---

The documentation for this struct was generated from the following file:

• src/cse/dynamics/c1e74e09d2251ce2fe7cbe6d512ddb6cb979667d135ae2a6fe0ffcabf87b7289.cse.h