From 78d8d5206b0986e81690d2cee6b7202abef5a1f2 Mon Sep 17 00:00:00 2001 From: Adrian Kummerlaender Date: Tue, 8 Jan 2019 10:43:28 +0100 Subject: Extract refinement scaffolding into separate units --- src/refinement/MakeHeader | 27 ++++ src/refinement/coupler2D.cpp | 36 +++++ src/refinement/coupler2D.h | 85 ++++++++++ src/refinement/coupler2D.hh | 348 +++++++++++++++++++++++++++++++++++++++++ src/refinement/grid2D.cpp | 34 ++++ src/refinement/grid2D.h | 87 +++++++++++ src/refinement/grid2D.hh | 208 ++++++++++++++++++++++++ src/refinement/module.mk | 27 ++++ src/refinement/refinement2D.h | 27 ++++ src/refinement/refinement2D.hh | 27 ++++ 10 files changed, 906 insertions(+) create mode 100644 src/refinement/MakeHeader create mode 100644 src/refinement/coupler2D.cpp create mode 100644 src/refinement/coupler2D.h create mode 100644 src/refinement/coupler2D.hh create mode 100644 src/refinement/grid2D.cpp create mode 100644 src/refinement/grid2D.h create mode 100644 src/refinement/grid2D.hh create mode 100644 src/refinement/module.mk create mode 100644 src/refinement/refinement2D.h create mode 100644 src/refinement/refinement2D.hh (limited to 'src/refinement') diff --git a/src/refinement/MakeHeader b/src/refinement/MakeHeader new file mode 100644 index 0000000..bfcbf33 --- /dev/null +++ b/src/refinement/MakeHeader @@ -0,0 +1,27 @@ +# This file is part of the OpenLB library +# +# Copyright (C) 2019 Adrian Kummerländer +# 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. + + +generic := + +precompiled := grid2D \ + coupler2D diff --git a/src/refinement/coupler2D.cpp b/src/refinement/coupler2D.cpp new file mode 100644 index 0000000..37997f5 --- /dev/null +++ b/src/refinement/coupler2D.cpp @@ -0,0 +1,36 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2019 Adrian Kummerländer + * 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. + */ + +#include "coupler2D.h" +#include "coupler2D.hh" + +#include "dynamics/latticeDescriptors.h" +#include "dynamics/latticeDescriptors.hh" + +namespace olb { + +template class Coupler2D; +template class FineCoupler2D; +template class CoarseCoupler2D; + +} diff --git a/src/refinement/coupler2D.h b/src/refinement/coupler2D.h new file mode 100644 index 0000000..b218eff --- /dev/null +++ b/src/refinement/coupler2D.h @@ -0,0 +1,85 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2019 Adrian Kummerländer + * 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. +*/ + +#ifndef REFINEMENT_COUPLER_2D_H +#define REFINEMENT_COUPLER_2D_H + +#include "grid2D.h" + +namespace olb { + + +template class DESCRIPTOR> +class Coupler2D { +protected: + Grid2D& _coarse; + Grid2D& _fine; + + const int _coarseSize; + const int _fineSize; + const bool _vertical; + + Vector _physOrigin; + Vector _coarseOrigin; + Vector _fineOrigin; + + Vector getFineLatticeR(int y) const; + Vector getCoarseLatticeR(int y) const; + +public: + Coupler2D(Grid2D& coarse, Grid2D& fine, + Vector origin, Vector extend); + +}; + +template class DESCRIPTOR> +class FineCoupler2D : public Coupler2D { +private: + std::vector _c2f_rho; + std::vector> _c2f_u; + std::vector::q>> _c2f_fneq; + +public: + FineCoupler2D(Grid2D& coarse, Grid2D& fine, + Vector origin, Vector extend); + + void store(); + void interpolate(); + void couple(); + +}; + +template class DESCRIPTOR> +class CoarseCoupler2D : public Coupler2D { +public: + CoarseCoupler2D(Grid2D& coarse, Grid2D& fine, + Vector origin, Vector extend); + + void couple(); + +}; + + +} + +#endif diff --git a/src/refinement/coupler2D.hh b/src/refinement/coupler2D.hh new file mode 100644 index 0000000..49efe57 --- /dev/null +++ b/src/refinement/coupler2D.hh @@ -0,0 +1,348 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2019 Adrian Kummerländer + * 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. +*/ + +#ifndef REFINEMENT_COUPLER_2D_HH +#define REFINEMENT_COUPLER_2D_HH + +#include "coupler2D.h" + +#include "dynamics/lbHelpers.h" + +namespace olb { + + +template class DESCRIPTOR> +void computeFeq(const Cell& cell, T fEq[DESCRIPTOR::q]) +{ + T rho{}; + T u[2] {}; + cell.computeRhoU(rho, u); + const T uSqr = u[0]*u[0] + u[1]*u[1]; + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + fEq[iPop] = lbHelpers::equilibrium(iPop, rho, u, uSqr); + } +} + +template class DESCRIPTOR> +void computeFneq(const Cell& cell, T fNeq[DESCRIPTOR::q]) +{ + T rho{}; + T u[2] {}; + cell.computeRhoU(rho, u); + lbHelpers::computeFneq(cell, fNeq, rho, u); +} + +template +T order4interpolation(T fm3, T fm1, T f1, T f3) +{ + return 9./16. * (fm1 + f1) - 1./16. * (fm3 + f3); +} + +template +T order3interpolation(T fm1, T f1, T f3) +{ + return 3./8. * fm1 + 3./4. * f1 - 1./8. * f3; +} + +template +T order2interpolation(T f0, T f1) +{ + return 0.5 * (f0 + f1); +} + +template class DESCRIPTOR> +void computeRestrictedFneq(const SuperLattice2D& lattice, Vector pos, T restrictedFneq[DESCRIPTOR::q]) +{ + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + T fNeq[DESCRIPTOR::q] {}; + computeFneq(lattice.get(pos[0], pos[1] + DESCRIPTOR::c[iPop][0], pos[2] + DESCRIPTOR::c[iPop][1]), fNeq); + + for (int jPop=0; jPop < DESCRIPTOR::q; ++jPop) { + restrictedFneq[jPop] += fNeq[jPop]; + } + } + + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + restrictedFneq[iPop] /= DESCRIPTOR::q; + } +} + + +template class DESCRIPTOR> +Vector Coupler2D::getFineLatticeR(int y) const +{ + if (_vertical) { + return _fineOrigin + Vector {0, 0, y}; + } + else { + return _fineOrigin + Vector {0, y, 0}; + } +} + +template class DESCRIPTOR> +Vector Coupler2D::getCoarseLatticeR(int y) const +{ + if (_vertical) { + return _coarseOrigin + Vector {0, 0, y}; + } + else { + return _coarseOrigin + Vector {0, y, 0}; + } +} + +template class DESCRIPTOR> +Coupler2D::Coupler2D(Grid2D& coarse, Grid2D& fine, + Vector origin, Vector extend): + _coarse(coarse), + _fine(fine), + _coarseSize(floor(extend.norm() / coarse.getConverter().getPhysDeltaX() + 0.5)+1), + _fineSize(2*_coarseSize-1), + _vertical(util::nearZero(extend[0])) +{ + OLB_ASSERT(util::nearZero(extend[0]) || util::nearZero(extend[1]), "Coupling is only implemented alongside unit vectors"); + + const auto& coarseGeometry = _coarse.getCuboidGeometry(); + const auto& fineGeometry = _fine.getCuboidGeometry(); + + Vector tmpLatticeOrigin{}; + coarseGeometry.getLatticeR(origin, tmpLatticeOrigin); + _physOrigin = coarseGeometry.getPhysR(tmpLatticeOrigin.toStdVector()); + + coarseGeometry.getLatticeR(_physOrigin, _coarseOrigin); + fineGeometry.getLatticeR(_physOrigin, _fineOrigin); +} + + +template class DESCRIPTOR> +FineCoupler2D::FineCoupler2D(Grid2D& coarse, Grid2D& fine, + Vector origin, Vector extend): + Coupler2D(coarse, fine, origin, extend), + _c2f_rho(this->_coarseSize), + _c2f_u(this->_coarseSize, Vector(T{})), + _c2f_fneq(this->_coarseSize, Vector::q>(T{})) +{ + OstreamManager clout(std::cout,"C2F"); + clout << "coarse origin: " << this->_coarseOrigin[0] << " " << this->_coarseOrigin[1] << " " << this->_coarseOrigin[2] << std::endl; + clout << "fine origin: " << this->_fineOrigin[0] << " " << this->_fineOrigin[1] << " " << this->_fineOrigin[2] << std::endl; + clout << "fine size: " << this->_fineSize << std::endl; +} + +template class DESCRIPTOR> +void FineCoupler2D::store() +{ + auto& coarseLattice = this->_coarse.getSuperLattice(); + + for (int y=0; y < this->_coarseSize; ++y) { + const auto pos = this->getCoarseLatticeR(y); + + T rho{}; + T u[2] {}; + T fNeq[DESCRIPTOR::q] {}; + coarseLattice.get(pos).computeRhoU(rho, u); + computeFneq(coarseLattice.get(pos), fNeq); + + _c2f_rho[y] = rho; + _c2f_u[y] = Vector(u); + _c2f_fneq[y] = Vector::q>(fNeq); + } +} + +template class DESCRIPTOR> +void FineCoupler2D::interpolate() +{ + auto& coarseLattice = this->_coarse.getSuperLattice(); + + for (int y=0; y < this->_coarseSize; ++y) { + const auto coarsePos = this->getCoarseLatticeR(y); + + T rho{}; + T u[2] {}; + coarseLattice.get(coarsePos).computeRhoU(rho, u); + _c2f_rho[y] = order2interpolation(rho, _c2f_rho[y]); + _c2f_u[y][0] = order2interpolation(u[0], _c2f_u[y][0]); + _c2f_u[y][1] = order2interpolation(u[1], _c2f_u[y][1]); + + T fNeq[DESCRIPTOR::q] {}; + computeFneq(coarseLattice.get(coarsePos), fNeq); + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + _c2f_fneq[y][iPop] = order2interpolation(fNeq[iPop], _c2f_fneq[y][iPop]); + } + } +} + +template class DESCRIPTOR> +void FineCoupler2D::couple() +{ + auto& coarseLattice = this->_coarse.getSuperLattice(); + auto& fineLattice = this->_fine.getSuperLattice(); + + for (int y=0; y < this->_coarseSize; ++y) { + const auto coarsePos = this->getCoarseLatticeR(y); + const auto finePos = this->getFineLatticeR(2*y); + + T fEq[DESCRIPTOR::q] {}; + computeFeq(coarseLattice.get(coarsePos), fEq); + + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + fineLattice.get(finePos)[iPop] = fEq[iPop] + this->_coarse.getScalingFactor() * _c2f_fneq[y][iPop]; + } + } + + for (int y=1; y < this->_coarseSize-2; ++y) { + const T rho = order4interpolation( + _c2f_rho[y-1], + _c2f_rho[y], + _c2f_rho[y+1], + _c2f_rho[y+2] + ); + T u[2] {}; + u[0] = order4interpolation( + _c2f_u[y-1][0], + _c2f_u[y][0], + _c2f_u[y+1][0], + _c2f_u[y+2][0] + ); + u[1] = order4interpolation( + _c2f_u[y-1][1], + _c2f_u[y][1], + _c2f_u[y+1][1], + _c2f_u[y+2][1] + ); + const T uSqr = u[0]*u[0] + u[1]*u[1]; + + const auto finePos = this->getFineLatticeR(1+2*y); + + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + const T fneq = order4interpolation( + _c2f_fneq[y-1][iPop], + _c2f_fneq[y][iPop], + _c2f_fneq[y+1][iPop], + _c2f_fneq[y+2][iPop] + ); + + fineLattice.get(finePos)[iPop] = lbHelpers::equilibrium(iPop, rho, u, uSqr) + this->_coarse.getScalingFactor() * fneq; + } + } + + { + const T rho = order3interpolation( + _c2f_rho[0], + _c2f_rho[1], + _c2f_rho[2] + ); + T u[2] {}; + u[0] = order3interpolation( + _c2f_u[0][0], + _c2f_u[1][0], + _c2f_u[2][0] + ); + u[1] = order3interpolation( + _c2f_u[0][1], + _c2f_u[1][1], + _c2f_u[2][1] + ); + const T uSqr = u[0]*u[0] + u[1]*u[1]; + + const auto finePos = this->getFineLatticeR(1); + + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + const T fneq = order3interpolation( + _c2f_fneq[0][iPop], + _c2f_fneq[1][iPop], + _c2f_fneq[2][iPop] + ); + fineLattice.get(finePos)[iPop] = lbHelpers::equilibrium(iPop, rho, u, uSqr) + this->_coarse.getScalingFactor() * fneq; + } + } + + { + const T rho = order3interpolation( + _c2f_rho[this->_coarseSize-1], + _c2f_rho[this->_coarseSize-2], + _c2f_rho[this->_coarseSize-3] + ); + T u[2] {}; + u[0] = order3interpolation( + _c2f_u[this->_coarseSize-1][0], + _c2f_u[this->_coarseSize-2][0], + _c2f_u[this->_coarseSize-3][0] + ); + u[1] = order3interpolation( + _c2f_u[this->_coarseSize-1][1], + _c2f_u[this->_coarseSize-2][1], + _c2f_u[this->_coarseSize-3][1] + ); + const T uSqr = u[0]*u[0] + u[1]*u[1]; + + const auto finePos = this->getFineLatticeR(this->_fineSize-2); + + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + const T fneq = order3interpolation( + _c2f_fneq[this->_coarseSize-1][iPop], + _c2f_fneq[this->_coarseSize-2][iPop], + _c2f_fneq[this->_coarseSize-3][iPop] + ); + fineLattice.get(finePos)[iPop] = lbHelpers::equilibrium(iPop, rho, u, uSqr) + this->_coarse.getScalingFactor() * fneq; + } + } +} + + +template class DESCRIPTOR> +CoarseCoupler2D::CoarseCoupler2D( + Grid2D& coarse, Grid2D& fine, + Vector origin, Vector extend): + Coupler2D(coarse, fine, origin, extend) +{ + OstreamManager clout(std::cout,"F2C"); + clout << "coarse origin: " << this->_coarseOrigin[0] << " " << this->_coarseOrigin[1] << " " << this->_coarseOrigin[2] << std::endl; + clout << "fine origin: " << this->_fineOrigin[0] << " " << this->_fineOrigin[1] << " " << this->_fineOrigin[2] << std::endl; + clout << "coarse size: " << this->_coarseSize << std::endl; +} + +template class DESCRIPTOR> +void CoarseCoupler2D::couple() +{ + auto& fineLattice = this->_fine.getSuperLattice(); + auto& coarseLattice = this->_coarse.getSuperLattice(); + + for (int y=0; y < this->_coarseSize; ++y) { + const auto finePos = this->getFineLatticeR(2*y); + const auto coarsePos = this->getCoarseLatticeR(y); + + T fEq[DESCRIPTOR::q] {}; + computeFeq(fineLattice.get(finePos), fEq); + + T fNeq[DESCRIPTOR::q] {}; + computeRestrictedFneq(fineLattice, finePos, fNeq); + + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + coarseLattice.get(coarsePos)[iPop] = fEq[iPop] + this->_coarse.getInvScalingFactor() * fNeq[iPop]; + } + } +} + + +} + +#endif diff --git a/src/refinement/grid2D.cpp b/src/refinement/grid2D.cpp new file mode 100644 index 0000000..b371d0c --- /dev/null +++ b/src/refinement/grid2D.cpp @@ -0,0 +1,34 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2019 Adrian Kummerländer + * 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. + */ + +#include "grid2D.h" +#include "grid2D.hh" + +#include "dynamics/latticeDescriptors.h" +#include "dynamics/latticeDescriptors.hh" + +namespace olb { + +template class Grid2D; + +} diff --git a/src/refinement/grid2D.h b/src/refinement/grid2D.h new file mode 100644 index 0000000..fda38ed --- /dev/null +++ b/src/refinement/grid2D.h @@ -0,0 +1,87 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2019 Adrian Kummerländer + * 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. +*/ + +#ifndef REFINEMENT_GRID_2D_H +#define REFINEMENT_GRID_2D_H + +#include +#include + +#include "core/unitConverter.h" +#include "core/superLattice2D.h" +#include "geometry/superGeometry2D.h" +#include "geometry/cuboidGeometry2D.h" +#include "geometry/superGeometry2D.h" +#include "communication/loadBalancer.h" +#include "functors/analytical/indicator/indicatorF2D.h" + +namespace olb { + + +template class DESCRIPTOR> class FineCoupler2D; +template class DESCRIPTOR> class CoarseCoupler2D; + +template class DESCRIPTOR> +class Grid2D { +private: + std::unique_ptr> _converter; + std::unique_ptr> _cuboids; + std::unique_ptr> _balancer; + std::unique_ptr> _geometry; + std::unique_ptr> _lattice; + + std::vector>> _fineGrids; + + std::vector>> _fineCouplers; + std::vector>> _coarseCouplers; + +public: + static std::unique_ptr> make(IndicatorF2D& domainF, int resolution, T tau, int re); + + Grid2D(IndicatorF2D& domainF, int resolution, T tau, int re); + + UnitConverter& getConverter(); + CuboidGeometry2D& getCuboidGeometry(); + LoadBalancer& getLoadBalancer(); + SuperGeometry2D& getSuperGeometry(); + SuperLattice2D& getSuperLattice(); + + T getScalingFactor(); + T getInvScalingFactor(); + + void collideAndStream(); + + FineCoupler2D& addFineCoupling( + Grid2D& fineGrid, Vector origin, Vector extend); + CoarseCoupler2D& addCoarseCoupling( + Grid2D& fineGrid, Vector origin, Vector extend); + + Grid2D& refine(IndicatorF2D& domainF); + Grid2D& refine(Vector origin, Vector extend); + +}; + + +} + +#endif diff --git a/src/refinement/grid2D.hh b/src/refinement/grid2D.hh new file mode 100644 index 0000000..86c3102 --- /dev/null +++ b/src/refinement/grid2D.hh @@ -0,0 +1,208 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2019 Adrian Kummerländer + * 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. +*/ + +#ifndef REFINEMENT_GRID_2D_HH +#define REFINEMENT_GRID_2D_HH + +#include "grid2D.h" +#include "coupler2D.hh" + +#include "communication/heuristicLoadBalancer.h" + +namespace olb { + + +template class DESCRIPTOR> +std::unique_ptr> Grid2D::make( + IndicatorF2D& domainF, + int resolution, T tau, int re) +{ + return std::unique_ptr>( + new Grid2D(domainF, resolution, tau, re) + ); +} + +template class DESCRIPTOR> +Grid2D::Grid2D(IndicatorF2D& domainF, int resolution, T tau, int re): + _converter(new UnitConverterFromResolutionAndRelaxationTime( + resolution, // resolution: number of voxels per charPhysL + tau, // latticeRelaxationTime: relaxation time, has to be greater than 0.5! + T{1}, // charPhysLength: reference length of simulation geometry + T{1}, // charPhysVelocity: maximal/highest expected velocity during simulation in __m / s__ + T{1./re}, // physViscosity: physical kinematic viscosity in __m^2 / s__ + T{1}, // physDensity: physical density in __kg / m^3__ + T{1})), + _cuboids(new CuboidGeometry2D( + domainF, + _converter->getConversionFactorLength(), + 1)), + _balancer(new HeuristicLoadBalancer( + *_cuboids)), + _geometry(new SuperGeometry2D( + *_cuboids, + *_balancer, + 2)), + _lattice(new SuperLattice2D( + *_geometry)) +{ + _converter->print(); +} + +template class DESCRIPTOR> +UnitConverter& Grid2D::getConverter() +{ + return *_converter; +} + +template class DESCRIPTOR> +CuboidGeometry2D& Grid2D::getCuboidGeometry() +{ + return *_cuboids; +} + +template class DESCRIPTOR> +LoadBalancer& Grid2D::getLoadBalancer() +{ + return *_balancer; +} + +template class DESCRIPTOR> +SuperGeometry2D& Grid2D::getSuperGeometry() +{ + return *_geometry; +} + +template class DESCRIPTOR> +SuperLattice2D& Grid2D::getSuperLattice() +{ + return *_lattice; +} + +template class DESCRIPTOR> +T Grid2D::getScalingFactor() +{ + return 4. - _converter->getLatticeRelaxationFrequency(); +} + +template class DESCRIPTOR> +T Grid2D::getInvScalingFactor() +{ + return 1./getScalingFactor(); +} + +template class DESCRIPTOR> +void Grid2D::collideAndStream() +{ + for ( auto& fineCoupler : _fineCouplers ) { + fineCoupler->store(); + } + + this->getSuperLattice().collideAndStream(); + + for ( auto& fineGrid : _fineGrids ) { + fineGrid->getSuperLattice().collideAndStream(); + } + + for ( auto& fineCoupler : _fineCouplers ) { + fineCoupler->interpolate(); + fineCoupler->couple(); + } + + for ( auto& fineGrid : _fineGrids ) { + fineGrid->getSuperLattice().collideAndStream(); + } + + for ( auto& fineCoupler : _fineCouplers ) { + fineCoupler->store(); + fineCoupler->couple(); + } + + for ( auto& coarseCoupler : _coarseCouplers ) { + coarseCoupler->couple(); + } +} + +template class DESCRIPTOR> +FineCoupler2D& Grid2D::addFineCoupling( + Grid2D& fineGrid, Vector origin, Vector extend) +{ + _fineCouplers.emplace_back( + new FineCoupler2D( + *this, fineGrid, origin, extend)); + return *_fineCouplers.back(); +} + +template class DESCRIPTOR> +CoarseCoupler2D& Grid2D::addCoarseCoupling( + Grid2D& fineGrid, Vector origin, Vector extend) +{ + _coarseCouplers.emplace_back( + new CoarseCoupler2D( + *this, fineGrid, origin, extend)); + return *_coarseCouplers.back(); +} + +template class DESCRIPTOR> +Grid2D& Grid2D::refine(IndicatorF2D& domainF) +{ + _fineGrids.emplace_back( + new Grid2D( + domainF, + 2*getConverter().getResolution(), + 2.0*getConverter().getLatticeRelaxationTime() - 0.5, + getConverter().getReynoldsNumber() + )); + return *_fineGrids.back(); +} + +template class DESCRIPTOR> +Grid2D& Grid2D::refine(Vector origin, Vector extend) +{ + IndicatorCuboid2D fineCuboid(extend, origin); + auto& fineGrid = refine(fineCuboid); + + const Vector extendX = {extend[0],0}; + const Vector extendY = {0,extend[1]}; + + addFineCoupling(fineGrid, origin, extendY); + addFineCoupling(fineGrid, origin + extendX, extendY); + addFineCoupling(fineGrid, origin + extendY, extendX); + addFineCoupling(fineGrid, origin, extendX); + + const T coarseDeltaX = getConverter().getPhysDeltaX(); + const Vector innerOrigin = origin + coarseDeltaX; + const Vector innerExtendX = extendX - Vector {2*coarseDeltaX,0}; + const Vector innerExtendY = extendY - Vector {0,2*coarseDeltaX}; + + addCoarseCoupling(fineGrid, innerOrigin, innerExtendY); + addCoarseCoupling(fineGrid, innerOrigin + innerExtendX, innerExtendY); + addCoarseCoupling(fineGrid, innerOrigin + innerExtendY, innerExtendX); + addCoarseCoupling(fineGrid, innerOrigin, innerExtendX); + + return fineGrid; +} + + +} + +#endif diff --git a/src/refinement/module.mk b/src/refinement/module.mk new file mode 100644 index 0000000..6e42e3e --- /dev/null +++ b/src/refinement/module.mk @@ -0,0 +1,27 @@ +# This file is part of the OpenLB library +# +# Copyright (C) 2017 Markus Mohrhard +# 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. + +current_dir := $(dir $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST))) + +include $(addsuffix /MakeHeader, $(current_dir)) + +LIB_OBJECTS += $(foreach file, $($(BUILDTYPE)), $(OBJDIR)/$(current_dir)$(file).o) diff --git a/src/refinement/refinement2D.h b/src/refinement/refinement2D.h new file mode 100644 index 0000000..2dc726d --- /dev/null +++ b/src/refinement/refinement2D.h @@ -0,0 +1,27 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2019 Adrian Kummerländer + * + * 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 REFINEMENT_2D_H +#define REFINEMENT_2D_H + +#include "grid2D.h" +#include "coupler2D.h" + +#endif diff --git a/src/refinement/refinement2D.hh b/src/refinement/refinement2D.hh new file mode 100644 index 0000000..b21af48 --- /dev/null +++ b/src/refinement/refinement2D.hh @@ -0,0 +1,27 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2019 Adrian Kummerländer + * + * 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 REFINEMENT_2D_HH +#define REFINEMENT_2D_HH + +#include "grid2D.hh" +#include "coupler2D.hh" + +#endif -- cgit v1.2.3