fixed: update minimum distance in nearest neighbor transfer

fixed: reversed indices in lagrange interpolator
add tests for 2D LR gauss point transfer functions

src/ASM/LR/ASMu2D.C

@@ -2095,9 +2095,13 @@ bool ASMu2D::transferGaussPtVarsN (const LR::LRSplineSurface* oldBasis,
         double v = vmin + dv * (xi[j] + 1.0);
         double dist = 1.0e16;
         size_t near = 0;
-        for (size_t k = 0; k < nGP; ++k)
-          if (hypot(oGP[k].u-u,oGP[k].v-v) < dist)
+        for (size_t k = 0; k < nGP; ++k) {
+          double nd = hypot(oGP[k].u-u,oGP[k].v-v);
+          if (nd < dist) {
             near = k;
+            dist = nd;
+          }
+        }
         newVars.push_back(oldVars[iOld*nGP+near]);
       }
   }

src/ASM/LR/Test/TestASMu2D.C

@@ -11,6 +11,7 @@
 //==============================================================================
 
 #include "ASMu2D.h"
+#include "GaussQuadrature.h"
 #include "SIM2D.h"
 #include "LRSpline/LRSplineSurface.h"
 
@@ -144,3 +145,57 @@ TEST(TestASMu2D, InterfaceChecker)
     }
   }
 }
+
+
+TEST(TestASMu2D, TransferGaussPtVars)
+{
+  SIM2D sim(1);
+  sim.opt.discretization = ASM::LRSpline;
+  sim.createDefaultModel();
+  ASMu2D* pch = static_cast<ASMu2D*>(sim.getPatch(1));
+  RealArray oldAr(9), newAr;
+  const double* xi = GaussQuadrature::getCoord(3);
+  size_t id[2];
+  for (size_t idx = 0; idx < 2; ++idx) {
+    SIM2D simNew(1);
+    simNew.opt.discretization = ASM::LRSpline;
+    simNew.createDefaultModel();
+    ASMu2D* pchNew = static_cast<ASMu2D*>(simNew.getPatch(1));
+    pchNew->uniformRefine(idx, 1);
+    for (id[1] = 0; id[1] < 3; ++id[1])
+      for (id[0] = 0; id[0] < 3; ++id[0])
+        oldAr[id[0]+id[1]*3] = (1.0 + xi[id[idx]]) / 2.0;
+    pchNew->transferGaussPtVars(pch->getSurface(), oldAr, newAr, 3);
+    size_t k = 0;
+    for (size_t iEl = 0; iEl < 2; ++iEl) {
+      for (id[1] = 0; id[1] < 3; ++id[1])
+        for (id[0] = 0; id[0] < 3; ++id[0], ++k)
+          EXPECT_FLOAT_EQ(newAr[k], 0.5*iEl + 0.5*(xi[id[idx]] + 1.0) / 2.0);
+    }
+  }
+}
+
+
+TEST(TestASMu2D, TransferGaussPtVarsN)
+{
+  SIM2D sim(1), sim2(1);
+  sim.opt.discretization = sim2.opt.discretization = ASM::LRSpline;
+  sim.createDefaultModel();
+  sim2.createDefaultModel();
+  ASMu2D* pch = static_cast<ASMu2D*>(sim.getPatch(1));
+  ASMu2D* pchNew = static_cast<ASMu2D*>(sim2.getPatch(1));
+  pchNew->uniformRefine(0, 1);
+  RealArray oldAr(9), newAr;
+  std::iota(oldAr.begin(), oldAr.end(), 1);
+
+  pchNew->transferGaussPtVarsN(pch->getSurface(), oldAr, newAr, 3);
+  static RealArray refAr = {{1.0, 1.0, 2.0,
+                             4.0, 4.0, 5.0,
+                             7.0, 7.0, 8.0,
+                             2.0, 3.0, 3.0,
+                             5.0, 6.0, 6.0,
+                             8.0, 9.0, 9.0}};
+  EXPECT_EQ(refAr.size(), newAr.size());
+  for (size_t i = 0; i < refAr.size(); ++i)
+    EXPECT_FLOAT_EQ(refAr[i], newAr[i]);
+}

src/Utility/LagrangeInterpolator.C

@@ -26,10 +26,10 @@ double LagrangeInterpolator::evaluate(double x,
 
 Matrix LagrangeInterpolator::get(const std::vector<double>& new_grid)
 {
-  Matrix result(grid.size(), new_grid.size());
+  Matrix result(new_grid.size(), grid.size());
   for (size_t i = 0; i < grid.size(); ++i)
     for (size_t j = 0; j < new_grid.size(); ++j)
-      result(i+1, j+1) =  Lagrange(new_grid[j], i, grid);
+      result(j+1, i+1) =  Lagrange(new_grid[j], i, grid);
 
   return result;
 }