Conclude refinement method implementation section

6 files changed, 98 insertions, 23 deletions

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 <typename T, template<typename> class DESCRIPTOR>
+void computeRestrictedFneq(const SuperLattice2D<T,DESCRIPTOR>& lattice,
+                           Vector<int,3> latticeR,
+                           T restrictedFneq[DESCRIPTOR<T>::q])
+{
+  for (int iPop=0; iPop < DESCRIPTOR<T>::q; ++iPop) {
+    const auto neighbor = latticeR
+                        + {0, DESCRIPTOR<T>::c[iPop][0], DESCRIPTOR<T>::c[iPop][1]};
+    Cell<T,DESCRIPTOR> cell;
+    lattice.get(neighbor, cell);
+
+    T fNeq[DESCRIPTOR<T>::q] {};
+    lbHelpers<T,DESCRIPTOR>::computeFneq(cell, fNeq);
+
+    for (int jPop=0; jPop < DESCRIPTOR<T>::q; ++jPop) {
+      restrictedFneq[jPop] += fNeq[jPop];
+    }
+  }
+
+  for (int iPop=0; iPop < DESCRIPTOR<T>::q; ++iPop) {
+    restrictedFneq[iPop] /= DESCRIPTOR<T>::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<int,3>& getFineLatticeR(int y) const;
   const Vector<int,3>& 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 <typename T, template<typename> class DESCRIPTOR>
 class FineCoupler2D : public Coupler2D<T,DESCRIPTOR> {
 private:
-  std::vector<T>           _c2f_rho;
-  std::vector<Vector<T,2>> _c2f_u;
+  std::vector<Vector<T,1>>                _c2f_rho;
+  std::vector<Vector<T,DESCRIPTOR<T>::d>> _c2f_u;
   std::vector<Vector<T,DESCRIPTOR<T>::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<T,DESCRIPTOR> fineCell;
+  fineLattice.get(finePos, fineCell);
+
+  for (int iPop=0; iPop < DESCRIPTOR<T>::q; ++iPop) {
+    fineCell[iPop] = lbHelpers<T,DESCRIPTOR>::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 <typename T, unsigned N>

+Vector<T,N> order4interpolation(const std::vector<Vector<T,N>>& 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},