From b89b56b6b93d6b8df61954235c2ce6bd04bfd714 Mon Sep 17 00:00:00 2001 From: Adrian Kummerlaender Date: Tue, 15 Jan 2019 12:05:50 +0100 Subject: Conclude refinement method implementation section --- code/computeRestrictedFneq.cpp | 23 +++++++++++++++++++++ code/coupler2d.cpp | 2 +- code/fineCoupler2d.cpp | 4 ++-- code/fineCoupler2d_couple_extract.cpp | 18 +++++++++++++++++ content.tex | 36 ++++++++++++++++++++++++++++++++- quellen.bib | 38 +++++++++++++++++------------------ 6 files changed, 98 insertions(+), 23 deletions(-) create mode 100644 code/computeRestrictedFneq.cpp create mode 100644 code/fineCoupler2d_couple_extract.cpp diff --git a/code/computeRestrictedFneq.cpp b/code/computeRestrictedFneq.cpp new file mode 100644 index 0000000..cf796b1 --- /dev/null +++ b/code/computeRestrictedFneq.cpp @@ -0,0 +1,23 @@ +template class DESCRIPTOR> +void computeRestrictedFneq(const SuperLattice2D& lattice, + Vector latticeR, + T restrictedFneq[DESCRIPTOR::q]) +{ + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + const auto neighbor = latticeR + + {0, DESCRIPTOR::c[iPop][0], DESCRIPTOR::c[iPop][1]}; + Cell cell; + lattice.get(neighbor, cell); + + T fNeq[DESCRIPTOR::q] {}; + lbHelpers::computeFneq(cell, 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; + } +} diff --git a/code/coupler2d.cpp b/code/coupler2d.cpp index 9752de8..b34ec80 100644 --- a/code/coupler2d.cpp +++ b/code/coupler2d.cpp @@ -13,7 +13,7 @@ protected: const Vector& getFineLatticeR(int y) const; const Vector& getCoarseLatticeR(int y) const; - T getScalingFactor() const; + T getScalingFactor() const; // Skalierungsfaktor $(\ref{eq:scaleFneq})$ der Nicht-Equilibriumsverteilung T getInvScalingFactor() const; private: diff --git a/code/fineCoupler2d.cpp b/code/fineCoupler2d.cpp index 4cde254..7da499a 100644 --- a/code/fineCoupler2d.cpp +++ b/code/fineCoupler2d.cpp @@ -1,8 +1,8 @@ template class DESCRIPTOR> class FineCoupler2D : public Coupler2D { private: - std::vector _c2f_rho; - std::vector> _c2f_u; + std::vector> _c2f_rho; + std::vector::d>> _c2f_u; std::vector::q>> _c2f_fneq; public: diff --git a/code/fineCoupler2d_couple_extract.cpp b/code/fineCoupler2d_couple_extract.cpp new file mode 100644 index 0000000..089ed02 --- /dev/null +++ b/code/fineCoupler2d_couple_extract.cpp @@ -0,0 +1,18 @@ +for (int y=1; y < this->_coarseSize-2; ++y) { + const auto rho = order4interpolation(_c2f_rho, y); // Siehe Listing $\ref{lst:ipol4ord}$ + const auto u = order4interpolation(_c2f_u, y); + const auto fneq = order4interpolation(_c2f_fneq, y); + + const T uSqr = u*u; + + const auto finePos = this->getFineLatticeR(1+2*y); + Cell fineCell; + fineLattice.get(finePos, fineCell); + + for (int iPop=0; iPop < DESCRIPTOR::q; ++iPop) { + fineCell[iPop] = lbHelpers::equilibrium(iPop, rho[0], u.data, uSqr) + + this->getScalingFactor() * fneq[iPop]; + } + + fineLattice.set(finePos, fineCell); +} diff --git a/content.tex b/content.tex index 4a097d6..ea863f1 100644 --- a/content.tex +++ b/content.tex @@ -737,11 +737,12 @@ Zur umfassenden Beschreibung des Gitterverfeinerungsframework fehlt uns jetzt nu \newpage \subsection{Umsetzung des Verfahrens von Lagrava et al.} -Grundsätzlich implementiert jede Instanz von \class{Coupler2D} die Kopplung zweier Gitter in einer Richtung entlang einer durch Ursprung und Ausdehnung charakterisierten Linie innerhalb der physikalischen Simulationsdomäne. Für die Kopplung einer rechteckigen \class{RefiningGrid2D} Instanz werden von \method{Grid2D::refine} in diesem Fall acht Kopplungsobjekte erzeugt. +Grundsätzlich implementiert jede Instanz von \class{Coupler2D} die Kopplung zweier Gitter in einer Richtung entlang einer, durch Ursprung und Ausdehnung charakterisierten, Linie innerhalb der physikalischen Simulationsdomäne. Für die Kopplung einer rechteckigen \class{RefiningGrid2D} Instanz werden von \method{Grid2D::refine} in diesem Fall acht Kopplungsobjekte erzeugt -- vier Seiten mit jeweils zwei Kopplern. \begin{listing}[H] \inputminted{cpp}{code/coupler2d.cpp} \caption{Gemeinsame Struktur beider Kopplungsklassen} +\label{lst:Coupler2D} \end{listing} Die im Zuge dieser Arbeit entwickelte Version von \class{Coupler2D} beschränkt sich hierbei auf zu einem Einheitsvektor parallele Gitterübergänge. Sowohl für die Kopplung der mit \class{CuboidGeometry2D} modellierbaren Aufteilungen als auch für das umzusetzende Verfahren ist diese Einschränkung kein Hindernis, da Lagrava et al. ebenfalls nur von horizontalen bzw. vertikalen Gitterübergängen ausgehen. @@ -751,8 +752,41 @@ Da \class{Grid2D} Methoden zur Diskretisierung physikalischer Koordinaten auf da \begin{listing}[H] \inputminted{cpp}{code/fineCoupler2d.cpp} \caption{Struktur des Kopplers von grob nach fein} +\label{lst:FineCoupler2D} \end{listing} +Wie in Listing~\ref{lst:FineCoupler2D} zu sehen, benötigt das Setzen der feinen Verteilungsfunktionen in \method{FineCoupler2D::couple} einen Zwischenspeicher der groben Verteilungsmomente und der groben Nicht-Equilibriumsverteilung entlang der Kopplungslinie. Dieser wird in der Methode \method{FineCoupler2D::store} gesetzt und dient in \method{FineCoupler2D::interpolate} der linearen Zeitinterpolation der groben Verteilungsfunktionen zu Zeitpunkt \(t+\delta t_f\) entsprechend der Ausführungen in Kapitel~\ref{kap:Algorithmus}. + +\begin{listing}[H] +\inputminted{cpp}{code/fineCoupler2d_couple_extract.cpp} +\caption{Ausschnitt der Methode \method{FineCoupler2D::couple}} +\label{lst:FineCoupler2D_couple_extract} +\end{listing} + +Zur Beleuchtung des Herzstücks der feinen Kopplung sehen wir in Listing~\ref{lst:FineCoupler2D_couple_extract} einen Ausschnitt der Kopplungsfunktion für Knoten \(x_{g \to f}^f \in \F\) mit räumlicher Interpolation der benötigten groben Werte. Zusammen mit der zugehörigen Interpolationsfunktion in Listing~\ref{lst:ipol4ord} lässt sich dabei sehen, wie sich das Verfeinerungsvefahren durch Verwenden von OpenLB Modulen wie den \class{lbHelpers} und der \class{Vector} Datenstruktur sehr nah an seiner mathematischen Formulierung umsetzen lässt. + +\begin{listing}[H] +\begin{minted}{cpp} +template +Vector order4interpolation(const std::vector>& data, int y) +{ + return 9./16. * (data[y] + data[y+1]) - 1./16. * (data[y-1] + data[y+2]); +} +\end{minted} +\caption{Templatefunktion der Interpolationsformel (\ref{eq:ipol4ord})} +\label{lst:ipol4ord} +\end{listing} + +Der Koppler \class{CoarseCoupler2D} zum Setzen der groben Verteilungsfunktionen gestaltet sich derweil einfacher, da kein Zwischenspeicher benötigt wird und nur eine Restriktionsoperation anzuwenden ist. + +\begin{listing}[H] +\inputminted{cpp}{code/computeRestrictedFneq.cpp} +\caption{Umsetzung der Restriktionsoperation (\ref{eq:neqAvgRestrictionF2G})} +\label{lst:CoarseCoupler2D_restriction} +\end{listing} + +Hiermit sind die zentralen Bestandteile der Umsetzung des Verfahrens von Lagrava et al. im Kontext des in dieser Arbeit entwickelten Gitterverfeinerungsframework für OpenLB beschrieben. Zum Abschluss verbleibt nun noch die Evaluierung der Qualität eben dieses Verfahrens anhand verschiedener Beispiele. + \newpage \section{Evaluierung} diff --git a/quellen.bib b/quellen.bib index b5500cd..4c6b1d4 100644 --- a/quellen.bib +++ b/quellen.bib @@ -53,28 +53,28 @@ adsnote = {Provided by the SAO/NASA Astrophysics Data System} }, @article{dupuisChopard03, - title = {Theory and applications of an alternative lattice Boltzmann grid refinement algorithm}, - author = {Dupuis, Alexandre and Chopard, Bastien}, - journal = {Phys. Rev. E}, - volume = {67}, - issue = {6}, - pages = {066707}, - year = {2003}, - month = {Jun}, + author = {Dupuis, Alexandre and Chopard, Bastien}, + title = {Theory and applications of an alternative lattice Boltzmann grid refinement algorithm}, + journal = {Phys. Rev. E}, + volume = {67}, + issue = {6}, + pages = {066707}, + year = {2003}, + month = {Jun}, publisher = {American Physical Society}, - doi = {10.1103/PhysRevE.67.066707}, + doi = {10.1103/PhysRevE.67.066707}, }, @article{filippova98, - title = "Grid Refinement for Lattice-BGK Models", - journal = "Journal of Computational Physics", - volume = "147", - number = "1", - pages = "219 - 228", - year = "1998", - issn = "0021-9991", - doi = {10.1006/jcph.1998.6089}, - author = {Olga {Filippova}, and Dieter {Hänel}} -} + author = {Olga {Filippova} and Dieter {Hänel}}, + title = {Grid Refinement for Lattice-BGK Models}, + journal = {Journal of Computational Physics}, + volume = 147, + number = 1, + pages = {219-228}, + year = 1998, + issn = {0021-9991}, + doi = {10.1006/jcph.1998.6089}, +}, @misc{olb12, author = {Krause, M.J. and Mink, A. and Trunk, R. and Klemens, F. and Maier, M.-L. and Mohrhard, M. and Claro Barreto, A. and Haußmann, M. and Gaedtke, M. and Ross-Jones, J.}, title = {OpenLB Release 1.2: Open Source Lattice Boltzmann Code}, -- cgit v1.2.3