From 94d3e79a8617f88dc0219cfdeedfa3147833719d Mon Sep 17 00:00:00 2001 From: Adrian Kummerlaender Date: Mon, 24 Jun 2019 14:43:36 +0200 Subject: Initialize at openlb-1-3 --- examples/laminar/poiseuille3d/poiseuille3d.cpp | 613 +++++++++++++++++++++++++ 1 file changed, 613 insertions(+) create mode 100755 examples/laminar/poiseuille3d/poiseuille3d.cpp (limited to 'examples/laminar/poiseuille3d/poiseuille3d.cpp') diff --git a/examples/laminar/poiseuille3d/poiseuille3d.cpp b/examples/laminar/poiseuille3d/poiseuille3d.cpp new file mode 100755 index 0000000..11a1eb1 --- /dev/null +++ b/examples/laminar/poiseuille3d/poiseuille3d.cpp @@ -0,0 +1,613 @@ +/* Lattice Boltzmann sample, written in C++, using the OpenLB + * library + * + * Copyright (C) 2018 Marc Haußmann, Mathias J. Krause + * E-mail contact: info@openlb.net + * The most recent release of OpenLB can be downloaded at + * + * + * 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. + */ + +/* poiseuille3d.cpp: + * This example examines a 3D Poseuille flow + * It illustrates the computation of error norms. + */ + + +#include "olb3D.h" +#include "olb3D.hh" + +#include +#include +#include +#include +#include + +using namespace olb; +using namespace olb::descriptors; +using namespace olb::graphics; +using namespace std; + +typedef double T; + +//#define MRT +#ifdef MRT +#define DESCRIPTOR ForcedMRTD3Q19Descriptor +#else +#define DESCRIPTOR D3Q19 +#endif + +typedef enum {forced, nonForced} FlowType; + +typedef enum {bounceBack, local, interpolated, bouzidi, freeSlip, partialSlip} BoundaryType; + + +// Parameters for the simulation setup +FlowType flowType = forced; +BoundaryType boundaryType = bouzidi; +const T length = 2.; // length of the pie +const T diameter = 1.; // diameter of the pipe +int N = 21; // resolution of the model +const T physU = 1.; // physical velocity +const T Re = 10.; // Reynolds number +const T physRho = 1.; // physical density +const T tau = 0.8; // lattice relaxation time +const T maxPhysT = 20.; // max. simulation time in s, SI unit +const T residuum = 1e-5; // residuum for the convergence check +const T tuner = 0.97; // for partialSlip only: 0->bounceBack, 1->freeSlip + +// Scaled Parameters +const T radius = diameter/2.; // radius of the pipe +const T physInterval = 0.0125*maxPhysT; // interval for the convergence check in s + + +// Stores geometry information in form of material numbers +void prepareGeometry( UnitConverter const& converter, + SuperGeometry3D& superGeometry ) +{ + + OstreamManager clout(std::cout, "prepareGeometry"); + + clout << "Prepare Geometry ..." << std::endl; + + Vector center0(-converter.getPhysDeltaX() * 0.2, radius, radius); + Vector center1(length, radius, radius); + if (flowType == forced) { + center0[0] -= 3.*converter.getPhysDeltaX(); + center1[0] += 3.*converter.getPhysDeltaX(); + } + IndicatorCylinder3D pipe(center0, center1, radius); + + superGeometry.rename(0, 2); + + superGeometry.rename(2, 1, pipe); + + if (flowType == nonForced) { + Vector origin(0, radius, radius); + Vector extend = origin; + + // Set material number for inflow + origin[0] = -converter.getPhysDeltaX() * 2; + extend[0] = converter.getPhysDeltaX() * 2; + IndicatorCylinder3D inflow(origin, extend, radius); + superGeometry.rename(2, 3, 1, inflow); + + // Set material number for outflow + origin[0] = length - 2 * converter.getPhysDeltaX(); + extend[0] = length + 2 * converter.getPhysDeltaX(); + IndicatorCylinder3D outflow(extend, origin, radius); + superGeometry.rename(2, 4, 1, outflow); + } + + // Removes all not needed boundary voxels outside the surface + superGeometry.clean(); + // Removes all not needed boundary voxels inside the surface + superGeometry.innerClean(); + superGeometry.checkForErrors(); + + superGeometry.print(); + + clout << "Prepare Geometry ... OK" << std::endl; +} + +// Set up the geometry of the simulation +void prepareLattice(SuperLattice3D& sLattice, + UnitConverterconst& converter, + Dynamics& bulkDynamics, + sOnLatticeBoundaryCondition3D& onBc, + sOffLatticeBoundaryCondition3D& offBc, + SuperGeometry3D& superGeometry) +{ + + OstreamManager clout( std::cout,"prepareLattice" ); + clout << "Prepare Lattice ..." << std::endl; + + const T omega = converter.getLatticeRelaxationFrequency(); + + // Material=0 -->do nothing + sLattice.defineDynamics( superGeometry, 0, &instances::getNoDynamics() ); + + // Material=1 -->bulk dynamics + sLattice.defineDynamics( superGeometry, 1, &bulkDynamics ); + + Vector center0(0, radius, radius); + Vector center1(length, radius, radius); + + std::vector origin = { length, radius, radius}; + std::vector axis = { 1, 0, 0 }; + + CirclePoiseuille3D poiseuilleU(origin, axis, converter.getCharLatticeVelocity(), radius); + + if (boundaryType == bounceBack) { + sLattice.defineDynamics( superGeometry, 2, &instances::getBounceBack() ); + } + else if (boundaryType == freeSlip) { + sLattice.defineDynamics(superGeometry, 2, &instances::getNoDynamics()); + onBc.addSlipBoundary( superGeometry, 2 ); + } + else if (boundaryType == partialSlip) { + sLattice.defineDynamics(superGeometry, 2, &instances::getNoDynamics()); + onBc.addPartialSlipBoundary(tuner, superGeometry, 2 ); + } + else if (boundaryType == bouzidi) { + sLattice.defineDynamics(superGeometry, 2, &instances::getNoDynamics() ); + + center0[0] -= 0.5*converter.getPhysDeltaX(); + center1[0] += 0.5*converter.getPhysDeltaX(); + if (flowType == forced) { + center0[0] -= 3.*converter.getPhysDeltaX(); + center1[0] += 3.*converter.getPhysDeltaX(); + } + IndicatorCylinder3D pipe(center0, center1, radius); + offBc.addZeroVelocityBoundary(superGeometry, 2, pipe); + } + else { + sLattice.defineDynamics( superGeometry, 2, &bulkDynamics ); + onBc.addVelocityBoundary( superGeometry, 2, omega ); + } + + if (flowType == nonForced) { + if (boundaryType == bouzidi) { + sLattice.defineDynamics(superGeometry, 3, &instances::getNoDynamics() ); + IndicatorCylinder3D pipe(center0, center1, radius); + offBc.addVelocityBoundary(superGeometry, 3, pipe); + offBc.defineU(superGeometry,3,poiseuilleU); + } + else { + // Material=3 -->bulk dynamics + sLattice.defineDynamics( superGeometry, 3, &bulkDynamics ); + onBc.addVelocityBoundary( superGeometry, 3, omega ); + } + // Material=4 -->bulk dynamics + sLattice.defineDynamics( superGeometry, 4, &bulkDynamics ); + onBc.addPressureBoundary( superGeometry, 4, omega ); + } + + if (flowType == forced) { + // Initial conditions + T D = converter.getLatticeLength(diameter); + + std::vector poiseuilleForce(3, T()); + poiseuilleForce[0] = 4. * converter.getLatticeViscosity() * converter.getCharLatticeVelocity() / (D * D / 4. ); + AnalyticalConst3D force( poiseuilleForce ); + + // Initialize force + sLattice.defineField(superGeometry, 1, force); + sLattice.defineField(superGeometry, 2, force ); + + + AnalyticalConst3D rhoF(1); + + sLattice.defineRhoU(superGeometry, 1, rhoF, poiseuilleU); + sLattice.iniEquilibrium(superGeometry, 1, rhoF, poiseuilleU); + sLattice.defineRhoU(superGeometry, 2, rhoF, poiseuilleU); + sLattice.iniEquilibrium(superGeometry, 2, rhoF, poiseuilleU); + } + else { + // Initial conditions + T p0 = 4. * converter.getPhysViscosity() * converter.getCharPhysVelocity() * length / (radius * radius); + + p0 = converter.getLatticePressure(p0); + AnalyticalLinear3D rho(-p0 / length * descriptors::invCs2(), 0, 0, p0 * descriptors::invCs2() + 1); + + std::vector velocity(3, T()); + AnalyticalConst3D uF(velocity); + + // Initialize all values of distribution functions to their local equilibrium + sLattice.defineRhoU(superGeometry, 0, rho, uF); + sLattice.iniEquilibrium(superGeometry, 0, rho, uF); + sLattice.defineRhoU(superGeometry, 1, rho, poiseuilleU); + sLattice.iniEquilibrium(superGeometry, 1, rho, poiseuilleU); + sLattice.defineRhoU(superGeometry, 2, rho, poiseuilleU); + sLattice.iniEquilibrium(superGeometry, 2, rho, poiseuilleU); + sLattice.defineRhoU(superGeometry, 3, rho, poiseuilleU); + sLattice.iniEquilibrium(superGeometry, 3, rho, poiseuilleU); + sLattice.defineRhoU(superGeometry, 4, rho, poiseuilleU); + sLattice.iniEquilibrium(superGeometry, 4, rho, poiseuilleU); + } + + // Make the lattice ready for simulation + sLattice.initialize(); + + clout << "Prepare Lattice ... OK" << std::endl; +} + +// Compute error norms +void error( SuperGeometry3D& superGeometry, + SuperLattice3D& sLattice, + UnitConverter const& converter, + Dynamics& bulkDynamics, + SuperLatticePhysWallShearStress3D& wss) +{ + OstreamManager clout( std::cout,"error" ); + + int tmp[]= { }; + T result[2]= { }; + + // velocity error + const T maxVelocity = converter.getCharPhysVelocity(); + std::vector axisPoint = {length, radius, radius}; + std::vector axisDirection = { 1, 0, 0 }; + CirclePoiseuille3D uSol(axisPoint, axisDirection, maxVelocity, radius); + SuperLatticePhysVelocity3D u( sLattice,converter ); + auto indicatorF = superGeometry.getMaterialIndicator(1); + + SuperAbsoluteErrorL1Norm3D absVelocityErrorNormL1(u, uSol, indicatorF); + absVelocityErrorNormL1(result, tmp); + clout << "velocity-L1-error(abs)=" << result[0]; + SuperRelativeErrorL1Norm3D relVelocityErrorNormL1(u, uSol, indicatorF); + relVelocityErrorNormL1(result, tmp); + clout << "; velocity-L1-error(rel)=" << result[0] << std::endl; + + SuperAbsoluteErrorL2Norm3D absVelocityErrorNormL2(u, uSol, indicatorF); + absVelocityErrorNormL2(result, tmp); + clout << "velocity-L2-error(abs)=" << result[0]; + SuperRelativeErrorL2Norm3D relVelocityErrorNormL2(u, uSol, indicatorF); + relVelocityErrorNormL2(result, tmp); + clout << "; velocity-L2-error(rel)=" << result[0] << std::endl; + + SuperAbsoluteErrorLinfNorm3D absVelocityErrorNormLinf(u, uSol, indicatorF); + absVelocityErrorNormLinf(result, tmp); + clout << "velocity-Linf-error(abs)=" << result[0]; + SuperRelativeErrorLinfNorm3D relVelocityErrorNormLinf(u, uSol, indicatorF); + relVelocityErrorNormLinf(result, tmp); + clout << "; velocity-Linf-error(rel)=" << result[0] << std::endl; + + // strainRate error + CirclePoiseuilleStrainRate3D sSol( converter, radius ); + SuperLatticePhysStrainRate3D s( sLattice,converter ); + + SuperAbsoluteErrorL1Norm3D absStrainRateErrorNormL1(s, sSol, indicatorF); + absStrainRateErrorNormL1(result, tmp); + clout << "strainRate-L1-error(abs)=" << result[0]; + SuperRelativeErrorL1Norm3D relStrainRateErrorNormL1(s, sSol, indicatorF); + relStrainRateErrorNormL1(result, tmp); + clout << "; strainRate-L1-error(rel)=" << result[0] << std::endl; + + SuperAbsoluteErrorL2Norm3D absStrainRateErrorNormL2(s, sSol, indicatorF); + absStrainRateErrorNormL2(result, tmp); + clout << "strainRate-L2-error(abs)=" << result[0]; + SuperRelativeErrorL2Norm3D relStrainRateErrorNormL2(s, sSol, indicatorF); + relStrainRateErrorNormL2(result, tmp); + clout << "; strainRate-L2-error(rel)=" << result[0] << std::endl; + + SuperAbsoluteErrorLinfNorm3D absStrainRateErrorNormLinf(s, sSol, indicatorF); + absStrainRateErrorNormLinf(result, tmp); + clout << "strainRate-Linf-error(abs)=" << result[0]; + SuperRelativeErrorLinfNorm3D relStrainRateErrorNormLinf(s, sSol, indicatorF); + relStrainRateErrorNormLinf(result, tmp); + clout << "; strainRate-Linf-error(rel)=" << result[0] << std::endl; + + // wallShearStress error + AnalyticalConst3D wssSol(4. * converter.getPhysViscosity() * converter.getPhysDensity() * maxVelocity / diameter); + SuperLatticeFfromAnalyticalF3D wssSolLattice (wssSol, sLattice); + + auto indicatorB = superGeometry.getMaterialIndicator(2); + + SuperAbsoluteErrorL1Norm3D absWallShearStressErrorNormL1(wss, wssSol, indicatorB); + absWallShearStressErrorNormL1(result, tmp); + clout << "wss-L1-error(abs)=" << result[0]; + SuperRelativeErrorL1Norm3D relWallShearStressErrorNormL1(wss, wssSol, indicatorB); + relWallShearStressErrorNormL1(result, tmp); + clout << "; wss-L1-error(rel)=" << result[0] << std::endl; + + SuperAbsoluteErrorL2Norm3D absWallShearStressErrorNormL2(wss, wssSol, indicatorB); + absWallShearStressErrorNormL2(result, tmp); + clout << "wss-L2-error(abs)=" << result[0]; + SuperRelativeErrorL2Norm3D relWallShearStressErrorNormL2(wss, wssSol, indicatorB); + relWallShearStressErrorNormL2(result, tmp); + clout << "; wss-L2-error(rel)=" << result[0] << std::endl; + + SuperAbsoluteErrorLinfNorm3D absWallShearStressErrorNormLinf(wss, wssSol, indicatorB); + absWallShearStressErrorNormLinf(result, tmp); + clout << "wss-Linf-error(abs)=" << result[0]; + SuperRelativeErrorLinfNorm3D relWallShearStressErrorNormLinf(wss, wssSol, indicatorB); + relWallShearStressErrorNormLinf(result, tmp); + clout << "; wss-Linf-error(rel)=" << result[0] << std::endl; + + if (flowType == nonForced) { + // pressure error + T p0 = 4. * converter.getPhysViscosity() * maxVelocity * length / (radius * radius); + AnalyticalLinear3D pressureSol(-p0 / length, 0, 0, p0); + SuperLatticePhysPressure3D pressure(sLattice, converter); + + SuperAbsoluteErrorL1Norm3D absPressureErrorNormL1(pressure, pressureSol, indicatorF); + absPressureErrorNormL1(result, tmp); + clout << "pressure-L1-error(abs)=" << result[0]; + SuperRelativeErrorL1Norm3D relPressureErrorNormL1(pressure, pressureSol, indicatorF); + relPressureErrorNormL1(result, tmp); + clout << "; pressure-L1-error(rel)=" << result[0] << std::endl; + + SuperAbsoluteErrorL2Norm3D absPressureErrorNormL2(pressure, pressureSol, indicatorF); + absPressureErrorNormL2(result, tmp); + clout << "pressure-L2-error(abs)=" << result[0]; + SuperRelativeErrorL2Norm3D relPressureErrorNormL2(pressure, pressureSol, indicatorF); + relPressureErrorNormL2(result, tmp); + clout << "; pressure-L2-error(rel)=" << result[0] << std::endl; + + SuperAbsoluteErrorLinfNorm3D absPressureErrorNormLinf(pressure, pressureSol, indicatorF); + absPressureErrorNormLinf(result, tmp); + clout << "pressure-Linf-error(abs)=" << result[0]; + SuperRelativeErrorLinfNorm3D relPressureErrorNormLinf(pressure, pressureSol, indicatorF); + relPressureErrorNormLinf(result, tmp); + clout << "; pressure-Linf-error(rel)=" << result[0] << std::endl; + } +} + +// Output to console and files +void getResults( SuperLattice3D& sLattice, Dynamics& bulkDynamics, + UnitConverter const& converter, int iT, + SuperGeometry3D& superGeometry, Timer& timer, bool hasConverged, + SuperLatticePhysWallShearStress3D& wss) +{ + + OstreamManager clout( std::cout,"getResults" ); + + SuperVTMwriter3D vtmWriter( "poiseuille3d" ); + SuperLatticePhysVelocity3D velocity( sLattice, converter ); + SuperLatticePhysPressure3D pressure( sLattice, converter ); + vtmWriter.addFunctor( velocity ); + vtmWriter.addFunctor( pressure ); + vtmWriter.addFunctor( wss ); + + const int vtmIter = converter.getLatticeTime( maxPhysT/20. ); + const int statIter = converter.getLatticeTime( maxPhysT/20. ); + + if ( iT==0 ) { + // Writes the geometry, cuboid no. and rank no. as vti file for visualization + SuperLatticeGeometry3D geometry( sLattice, superGeometry ); + SuperLatticeCuboid3D cuboid( sLattice ); + SuperLatticeRank3D rank( sLattice ); + + vtmWriter.write( geometry ); + vtmWriter.write( cuboid ); + vtmWriter.write( rank ); + + vtmWriter.createMasterFile(); + } + + // Writes the vtm files and profile text file + if ( iT%vtmIter==0 || hasConverged ) { + vtmWriter.write( iT ); + + SuperEuklidNorm3D normVel( velocity ); + BlockReduction3D2D planeReduction( normVel, {0,0,1}, 600, BlockDataSyncMode::ReduceOnly ); + // write output as JPEG + heatmap::write(planeReduction, iT); + + } + + if ( hasConverged ) { + Gnuplot gplot( "centerVelocity" ); + T D = converter.getLatticeLength( diameter ); + for ( int iY=0; iY<=D; ++iY ) { + T dx = 1. / T(converter.getResolution()); + T point[3]= {T(),T(),T()}; + point[0] = length/2.; + point[1] = ( T )converter.getPhysLength(iY); + point[2] = ( T )radius; + const T maxVelocity = converter.getCharPhysVelocity(); + std::vector axisPoint = {length, radius, radius}; + std::vector axisDirection = { 1, 0, 0 }; + CirclePoiseuille3D uSol(axisPoint, axisDirection, maxVelocity, radius); + T analytical[3] = {T(),T(),T()}; + uSol( analytical,point ); + SuperLatticePhysVelocity3D velocity( sLattice, converter ); + AnalyticalFfromSuperF3D intpolateVelocity( velocity, true, 1 ); + T numerical[3] = {T(),T(),T()}; + intpolateVelocity( numerical,point ); + gplot.setData( iY*dx, {analytical[0],numerical[0]}, {"analytical","numerical"} ); + } + // Create PNG file + gplot.writePNG(); + } + + // Writes output on the console + if ( iT%statIter==0 || hasConverged ) { + // Timer console output + timer.update( iT ); + timer.printStep(); + + // Lattice statistics console output + sLattice.getStatistics().print( iT,converter.getPhysTime( iT ) ); + + // Error norms + error( superGeometry, sLattice, converter, bulkDynamics, wss ); + } +} + +int main( int argc, char* argv[] ) +{ + + // === 1st Step: Initialization === + olbInit( &argc, &argv ); + singleton::directories().setOutputDir( "./tmp/" ); + OstreamManager clout( std::cout,"main" ); + + if (argc > 1) { + if (argv[1][0]=='-'&&argv[1][1]=='h') { + OstreamManager clout( std::cout,"help" ); + clout<<"Usage: program [Resolution] [FlowType] [BoundaryType]"< 1) { + N = atoi(argv[1]); + if (N < 1) { + std::cerr << "Fluid domain is too small" << std::endl; + return 1; + } + } + + if (argc > 2) { + int flowTypeNumber = atoi(argv[2]); + if (flowTypeNumber < 0 || flowTypeNumber > (int)nonForced) { + std::cerr << "Unknown fluid flow type" << std::endl; + return 2; + } + flowType = (FlowType) flowTypeNumber; + } + + if (argc > 3) { + int boundaryTypeNumber = atoi(argv[3]); + if (boundaryTypeNumber < 0 || boundaryTypeNumber > (int) partialSlip) { + std::cerr << "Unknown boundary type" << std::endl; + return 3; + } + boundaryType = (BoundaryType) boundaryTypeNumber; + } + + UnitConverterFromResolutionAndRelaxationTime const converter( + int {N}, // resolution: number of voxels per charPhysL + (T) tau, // latticeRelaxationTime: relaxation time, have to be greater than 0.5! + (T) diameter, // charPhysLength: reference length of simulation geometry + (T) physU, // charPhysVelocity: maximal/highest expected velocity during simulation in __m / s__ + (T) diameter*physU/Re, // physViscosity: physical kinematic viscosity in __m^2 / s__ + (T) physRho // physDensity: physical density in __kg / m^3__ + ); + // Prints the converter log as console output + converter.print(); + // Writes the converter log in a file + converter.write("poiseuille3d"); + + + // === 2nd Step: Prepare Geometry === + + Vector center0(0, radius, radius); + Vector center1(length, radius, radius); + IndicatorCylinder3D pipe(center0, center1, radius); + IndicatorLayer3D extendedDomain(pipe, converter.getPhysDeltaX()); + + // Instantiation of a cuboidGeometry with weights +#ifdef PARALLEL_MODE_MPI + const int noOfCuboids = 2*singleton::mpi().getSize(); +#else // ifdef PARALLEL_MODE_MPI + const int noOfCuboids = 6; +#endif // ifdef PARALLEL_MODE_MPI + CuboidGeometry3D cuboidGeometry(extendedDomain, converter.getPhysDeltaX(), noOfCuboids); + if (flowType == forced) { + // Periodic boundaries in x-direction + cuboidGeometry.setPeriodicity( true, false, false ); + } + + // Instantiation of a loadBalancer + HeuristicLoadBalancer loadBalancer(cuboidGeometry); + + // Instantiation of a superGeometry + SuperGeometry3D superGeometry(cuboidGeometry, loadBalancer, 2); + + prepareGeometry(converter, superGeometry); + + // === 3rd Step: Prepare Lattice === + SuperLattice3D sLattice( superGeometry ); + + std::unique_ptr> bulkDynamics; + +#if defined(MRT) + if (flowType == forced) { + bulkDynamics.reset(new ForcedMRTdynamics( converter.getLatticeRelaxationFrequency(), instances::getBulkMomenta() )); + } + else { + bulkDynamics.reset(new MRTdynamics( converter.getLatticeRelaxationFrequency(), instances::getBulkMomenta() )); + } +#else + if (flowType == forced) { + bulkDynamics.reset(new ForcedBGKdynamics( converter.getLatticeRelaxationFrequency(), instances::getBulkMomenta() )); + } + else { + bulkDynamics.reset(new BGKdynamics( converter.getLatticeRelaxationFrequency(), instances::getBulkMomenta() )); + } +#endif + + + // choose between local and non-local boundary condition + sOnLatticeBoundaryCondition3D sOnBoundaryCondition( sLattice ); + sOffLatticeBoundaryCondition3D sOffBoundaryCondition(sLattice); + createBouzidiBoundaryCondition3D(sOffBoundaryCondition); + + if (boundaryType == local) { + createLocalBoundaryCondition3D (sOnBoundaryCondition); + } + else { + createInterpBoundaryCondition3D ( sOnBoundaryCondition ); + } + + prepareLattice(sLattice, converter, *bulkDynamics, sOnBoundaryCondition, sOffBoundaryCondition, superGeometry); + + // set up size-increased indicator and instantiate wall shear stress functor (wss) + Vector center0Extended(-converter.getPhysDeltaX() * 0.2, radius, radius); + Vector center1Extended(length, radius, radius); + if (flowType == forced) { + center0Extended[0] -= 4.*converter.getPhysDeltaX(); + center1Extended[0] += 4.*converter.getPhysDeltaX(); + } + IndicatorCylinder3D pipeExtended(center0Extended, center1Extended, radius); + IndicatorLayer3D indicatorExtended (pipeExtended, 0.9*converter.getConversionFactorLength()*N/11.); + SuperLatticePhysWallShearStress3D wss(sLattice, superGeometry, 2, converter, indicatorExtended); + + // === 4th Step: Main Loop with Timer === + clout << "starting simulation..." << endl; + Timer timer( converter.getLatticeTime( maxPhysT ), superGeometry.getStatistics().getNvoxel() ); + util::ValueTracer converge( converter.getLatticeTime( physInterval ), residuum ); + timer.start(); + + for ( int iT = 0; iT < converter.getLatticeTime( maxPhysT ); ++iT ) { + if ( converge.hasConverged() ) { + clout << "Simulation converged." << endl; + getResults( sLattice, *bulkDynamics, converter, iT, superGeometry, timer, converge.hasConverged(), wss ); + + break; + } + + // === 5th Step: Definition of Initial and Boundary Conditions === + // in this application no boundary conditions have to be adjusted + + // === 6th Step: Collide and Stream Execution === + sLattice.collideAndStream(); + + // === 7th Step: Computation and Output of the Results === + getResults( sLattice, *bulkDynamics, converter, iT, superGeometry, timer, converge.hasConverged(), wss ); + converge.takeValue( sLattice.getStatistics().getAverageEnergy(), true ); + } + + timer.stop(); + timer.printSummary(); +} -- cgit v1.2.3