Changeset 8180d8 for src/grid/grid_index_translations.cpp

Timestamp:

Apr 5, 2013, 12:39:30 PM (13 years ago)

Author:

Julian Iseringhausen <julian.iseringhausen@…>

Children:

4a709e

Parents:

f57182

Message:

Merge stashed open boundary stuff.

File:

• src/grid/grid_index_translations.cpp (modified) (2 diffs)

src/grid/grid_index_translations.cpp

@@ -31 +31 @@
 #endif
 
-#include <cassert>
-
 #include "base/helper.hpp"
+#include "grid/grid_double_iterator.hpp"
 #include "grid/grid_index_translations.hpp"
 #include "grid/grid.hpp"
@@ -40 +39 @@
 using namespace VMG;
 
-Index GridIndexTranslations::GlobalToLocal(const Index& index_global) const
+bool GridIndexTranslations::IsGridPointOf(const Grid& grid, const Index& index_finest)
 {
-  const Index index_local = index_global - Father()->Global().LocalBegin() + Father()->Local().Begin();
-  return index_local;
+  assert(grid.Father() != NULL);
+  return index_finest[0] % Helper::intpow(2, grid.Father()->MaxLevel() - grid.Level()) == 0 &&
+         index_finest[1] % Helper::intpow(2, grid.Father()->MaxLevel() - grid.Level()) == 0 &&
+         index_finest[2] % Helper::intpow(2, grid.Father()->MaxLevel() - grid.Level()) == 0;
 }
 
-Index GridIndexTranslations::GlobalToFiner(const Index& index_global)
+Index GridIndexTranslations::LocalToGlobal(const Grid& grid, const Index& index_local)
 {
-  const Index index_finer = 2 * index_global;
-  return index_finer;
+  return index_local - grid.Local().Begin() + grid.Global().LocalBegin();
 }
 
-Index GridIndexTranslations::GlobalToCoarser(const Index& index_global)
+Index GridIndexTranslations::LocalToGlobalFinest(const Grid& grid, const Index& index_local)
 {
-  assert(index_global % 2 == 0);
-  const Index index_coarser = index_global / 2;
-  return index_coarser;
+  return GlobalToGlobalFinest(grid, LocalToGlobal(grid, index_local));
 }
 
-Index GridIndexTranslations::GlobalToFiner(const Index& index_global, const int& num_levels)
+Index GridIndexTranslations::GlobalToLocal(const Grid& grid, const Index& index_global)
 {
-  const Index index_finer = Helper::intpow(2, num_levels) * index_global;
-  return index_finer;
+  return index_global - grid.Global().LocalBegin() + grid.Local().Begin();
 }
 
-Index GridIndexTranslations::GlobalToCoarser(const Index& index_global, const int& num_levels)
+Index GridIndexTranslations::GlobalToGlobalFinest(const Grid& grid, const Index& index_global)
 {
-  int quotient = Helper::intpow(2, num_levels);
-  assert(index_global % quotient == 0);
-  const Index index_coarser = index_global / quotient;
-  return index_coarser;
+  assert(grid.Father() != NULL);
+  return Helper::intpow(2, grid.Father()->MaxLevel() - grid.Level()) * index_global;
 }
 
-Index GridIndexTranslations::LocalToGlobal(const Index& index_local) const
+Index GridIndexTranslations::GlobalFinestToLocal(const Grid& grid, const Index& index_finest)
 {
-  const Index index_global = index_local - Father()->Local().Begin() + Father()->Global().LocalBegin();
-  return index_global;
+  return GlobalToLocal(grid, GlobalFinestToGlobal(grid, index_finest));
 }
 
-Index GridIndexTranslations::LocalToFiner(const Index& index_local) const
+Index GridIndexTranslations::GlobalFinestToGlobal(const Grid& grid, const Index& index_finest)
 {
-  assert(Father() != NULL);
-  assert(Father()->Father() != NULL);
-
-  const Multigrid& multigrid = *(Father()->Father());
-
-  assert(Father()->Level() < multigrid.MaxLevel());
-
-  const Index index_global_fine = GlobalToFiner(LocalToGlobal(index_local));
-  const Index index_local_fine = multigrid(Father()->Level()+1).Indexing().GlobalToLocal(index_global_fine);
-
-  return index_local_fine;
+  assert(grid.Father() != NULL);
+  assert(IsGridPointOf(grid, index_finest));
+  return index_finest / Helper::intpow(2, grid.Father()->MaxLevel() - grid.Level());
 }
 
-Index GridIndexTranslations::LocalToCoarser(const Index& index_local) const
+void GridIndexTranslations::GlobalCoarseToFine(Index& begin, Index& end)
 {
-  assert(Father() != NULL);
-  assert(Father()->Father() != NULL);
-
-  const Multigrid& multigrid = *(Father()->Father());
-
-  assert(Father()->Level() > multigrid.MinLevel());
-
-  const Index index_global_coarse = GlobalToCoarser(LocalToGlobal(index_local));
-  const Index index_local_coarse = multigrid(Father()->Level()-1).Indexing().GlobalToLocal(index_global_coarse);
-
-  return index_local_coarse;
+  for (int j=0; j<3; ++j) {
+    begin[j] = 2 * begin[j];
+    end[j] = 2 * (end[j]-1) + 1;
+  }
 }
 
-Index GridIndexTranslations::FinestGlobalToLocal(const Index& index_finest) const
+void GridIndexTranslations::GlobalFineToCoarse(Index& begin, Index& end)
 {
-  const Index index_local = GlobalToLocal(FinestGlobalToGlobal(index_finest));
-  return index_local;
+  for (int j=0; j<3; ++j) {
+    begin[j] = Helper::RoundUpToNextMultiple(begin[j], 2) / 2;
+    end[j] = Helper::RoundDownToNextMultiple(end[j]-1, 2) / 2 + 1;
+  }
 }
 
-Index GridIndexTranslations::FinestGlobalToGlobal(const Index& index_finest) const
+void GridIndexTranslations::GetGridAlignment(const Grid& grid_1, GridIteratorSet& bounds_1,
+                      const Grid& grid_2, GridIteratorSet& bounds_2)
 {
-  const int quotient = Helper::intpow(2, Father()->Father()->MaxLevel() - Father()->Level());
-  assert(index_finest % quotient == 0);
-  const Index index_global = index_finest / quotient;
-  return index_global;
-}
+  assert(grid_1.Father() != NULL);
+  assert(grid_2.Father() != NULL);
 
-void GridIndexTranslations::FineToCoarse(Index& begin, Index& end)
-{
-  Index last_point = end - 1;
+  if (grid_1.Level() == grid_2.Level()) {
+    const Index begin_global = grid_1.Global()
+                                     .LocalBegin()
+                                     .Clamp(grid_2.Global().LocalBegin(), grid_2.Global().LocalEnd());
 
-  for (int j=0; j<3; ++j) {
+    const Index end_global = grid_1.Global()
+                                   .LocalEnd()
+                                   .Clamp(grid_2.Global().LocalBegin(), grid_2.Global().LocalEnd());
 
-    if (begin[j] % 2 == 0)
-      begin[j] /= 2;
-    else
-      begin[j] = (begin[j]+1) / 2;
+    bounds_1 = GridIteratorSet(GlobalToLocal(grid_1, begin_global), GlobalToLocal(grid_2, end_global));
+    bounds_2 = GridIteratorSet(GlobalToLocal(grid_2, begin_global), GlobalToLocal(grid_2, end_global));
 
-    if (last_point[j] % 2 == 0)
-      last_point[j] /= 2;
-    else
-      last_point[j] = (last_point[j]-1) / 2;
+  } else {
+
+    const Grid& grid_c = (grid_1.Level() < grid_2.Level() ? grid_1 : grid_2);
+    const int global_mult = Helper::intpow(2, grid_c.Father()->MaxLevel() - grid_c.Level());
+
+    Index begin_finest = GlobalToGlobalFinest(grid_1, grid_1.Global().LocalBegin())
+                           .Clamp(GlobalToGlobalFinest(grid_2, grid_2.Global().LocalBegin()),
+                                  GlobalToGlobalFinest(grid_2, grid_2.Global().LocalEnd()-1));
+
+    Index end_finest = GlobalToGlobalFinest(grid_1, grid_1.Global().LocalEnd()-1)
+                         .Clamp(GlobalToGlobalFinest(grid_2, grid_2.Global().LocalBegin()),
+                                GlobalToGlobalFinest(grid_2, grid_2.Global().LocalEnd()-1));
+
+    for (int j=0; j<3; ++j) {
+      begin_finest[j] = Helper::RoundUpToNextMultiple(begin_finest[j], global_mult);
+      end_finest[j] = Helper::RoundDownToNextMultiple(end_finest[j], global_mult);
+    }
+
+    bounds_1 = GridIteratorSet(GlobalFinestToLocal(grid_1, begin_finest), GlobalFinestToLocal(grid_1, end_finest)+1);
+    bounds_2 = GridIteratorSet(GlobalFinestToLocal(grid_2, begin_finest), GlobalFinestToLocal(grid_2, end_finest)+1);
 
   }
-
-
-  end = last_point + 1;
 }
-
-void GridIndexTranslations::CoarseToFine(Index& begin, Index& end, const Index& size_global)
-{
-  for (int i=0; i<3; ++i) {
-
-    if (size_global[i] % 2 == 0) {
-
-      begin[i] = 2*begin[i];
-      end[i] = 2*end[i];
-
-    }else {
-
-      if (begin[i] > 0)
-        begin[i] = 2*begin[i] - 1;
-      end[i] = std::max(2*end[i] - 1, begin[i]);
-
-    }
-  }
-}