isce3-testing
diff --git a/‎cxx/isce3/core/Poly2d.cpp‎
Lines changed: 10 additions & 17 deletions b/‎cxx/isce3/core/Poly2d.cpp‎
Lines changed: 10 additions & 17 deletions
diff --git a/‎cxx/isce3/core/Poly2d.h‎
Lines changed: 51 additions & 56 deletions b/‎cxx/isce3/core/Poly2d.h‎
Lines changed: 51 additions & 56 deletions
diff --git a/‎cxx/isce3/core/Serialization.h‎
Lines changed: 6 additions & 6 deletions b/‎cxx/isce3/core/Serialization.h‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎cxx/isce3/cuda/core/gpuPoly2d.cu‎
Lines changed: 22 additions & 29 deletions b/‎cxx/isce3/cuda/core/gpuPoly2d.cu‎
Lines changed: 22 additions & 29 deletions
@@ -1,42 +1,35 @@
-//
-// Author: Joshua Cohen
-// Copyright 2017
-//
-
 #include <iostream>
 #include "Constants.h"
 #include "Poly2d.h"
 
-/** 
+/**
  * @param[in] azi azimuth or y value
  * @param[in] rng range or x value*/
 double isce3::core::Poly2d::
-eval(double azi, double rng) const {
+eval(double y, double x) const {
 
-    double xval = (rng - rangeMean) / rangeNorm;
-    double yval = (azi - azimuthMean) / azimuthNorm;
+    double xval = (x - xMean) / xNorm;
+    double yval = (y - yMean) / yNorm;
 
     double scalex;
     double scaley = 1.;
     double val = 0.;
-    for (int i=0; i<=azimuthOrder; i++,scaley*=yval) {
+    for (int i=0; i<=yOrder; i++,scaley*=yval) {
         scalex = 1.;
-        for (int j=0; j<=rangeOrder; j++,scalex*=xval) {
-            val += scalex * scaley * coeffs[IDX1D(i,j,rangeOrder+1)];
+        for (int j=0; j<=xOrder; j++,scalex*=xval) {
+            val += scalex * scaley * coeffs[IDX1D(i,j,xOrder+1)];
         }
     }
     return val;
 }
 
 void isce3::core::Poly2d::
 printPoly() const {
-    std::cout << "Polynomial Order: " << azimuthOrder << " - by - " << rangeOrder << std::endl;
-    for (int i=0; i<=azimuthOrder; i++) {
-        for (int j=0; j<=rangeOrder; j++) {
+    std::cout << "Polynomial Order: " << yOrder << " - by - " << xOrder << std::endl;
+    for (int i=0; i<=yOrder; i++) {
+        for (int j=0; j<=xOrder; j++) {
             std::cout << getCoeff(i,j) << " ";
         }
         std::cout << std::endl;
     }
 }
-
-// end of file
@@ -1,8 +1,3 @@
-//
-// Author: Joshua Cohen
-// Copyright 2017
-//
-
 #pragma once
 
 #include "forward.h"
@@ -12,60 +7,60 @@
 #include <vector>
 #include "Constants.h"
 
-/** Data structure for representing 1D polynomials
+/** Data structure for representing 2D polynomials
  *
- * Poly2D is function of the form 
+ * Poly2D is function of the form
  * \f[
- *     f\left( y, x \right) = \sum_{i=0}^{N_y} \sum_{j=0}^{N_x} a_{ij} \cdot \left( \frac{y-\mu_y}{\sigma_y} \right)^i 
- \cdot \left( \frac{x-\mu_x}{\sigma_x} \right)^j 
+ *     f\left( y, x \right) = \sum_{i=0}^{N_y} \sum_{j=0}^{N_x} a_{ij} \cdot \left( \frac{y-\mu_y}{\sigma_y} \right)^i
+ \cdot \left( \frac{x-\mu_x}{\sigma_x} \right)^j
  * \f]
  *
- * where \f$a_ij\f$ represents the coefficients, \f$\mu_x\f$ and \f$\mu_y\f$ represent the means and 
+ * where \f$a_ij\f$ represents the coefficients, \f$\mu_x\f$ and \f$\mu_y\f$ represent the means and
  * \f$\sigma_x\f$ and \f$\sigma_y\f$ represent the norms*/
 class isce3::core::Poly2d {
 public:
 
     /** Order of polynomial in range or x*/
-    int rangeOrder;
+    int xOrder;
     /** Order of polynomial in azimuth or y*/
-    int azimuthOrder;
+    int yOrder;
     /** Mean in range or x direction*/
-    double rangeMean;
+    double xMean;
     /** Mean in azimuth or y direction*/
-    double azimuthMean;
+    double yMean;
     /** Norm in range or x direction*/
-    double rangeNorm;
+    double xNorm;
     /** Norm in azimuth or y direction*/
-    double azimuthNorm;
+    double yNorm;
     /**Linearized vector of coefficients in row-major format*/
     std::vector<double> coeffs;
 
     /** Simple constructor
      *
-     * @param[in] ro Range Order
-     * @param[in] ao Azimuth Order
-     * @param[in] rm Range Mean
-     * @param[in] am Azimuth Mean
-     * @param[in] rn Range Norm
-     * @param[in] an Azimuth Norm*/
-    Poly2d(int ro, int ao, double rm, double am, double rn, double an) : rangeOrder(ro), 
-                                                                         azimuthOrder(ao), 
-                                                                         rangeMean(rm), 
-                                                                         azimuthMean(am),
-                                                                         rangeNorm(rn), 
-                                                                         azimuthNorm(an), 
-                                                                         coeffs((ro+1)*(ao+1)) 
+     * @param[in] xo x/Range Order
+     * @param[in] yo y/Azimuth Order
+     * @param[in] xm x/Range Mean
+     * @param[in] ym y/Azimuth Mean
+     * @param[in] xn x/Range Norm
+     * @param[in] yn y/Azimuth Norm*/
+    Poly2d(int xo, int yo, double xm, double ym, double xn, double yn) : xOrder(xo),
+                                                                         yOrder(yo),
+                                                                         xMean(xm),
+                                                                         yMean(ym),
+                                                                         xNorm(xn),
+                                                                         yNorm(yn),
+                                                                         coeffs((xo+1)*(yo+1))
                                                                          {}
 
     /** Empty constructor*/
     Poly2d() : Poly2d(-1,-1,0.,0.,1.,1.) {}
 
-    /** Copy constructor 
+    /** Copy constructor
      *
      * @param[in] p Poly2D object*/
-    Poly2d(const Poly2d &p) : rangeOrder(p.rangeOrder), azimuthOrder(p.azimuthOrder), 
-                              rangeMean(p.rangeMean), azimuthMean(p.azimuthMean), 
-                              rangeNorm(p.rangeNorm), azimuthNorm(p.azimuthNorm), 
+    Poly2d(const Poly2d &p) : xOrder(p.xOrder), yOrder(p.yOrder),
+                              xMean(p.xMean), yMean(p.yMean),
+                              xNorm(p.xNorm), yNorm(p.yNorm),
                               coeffs(p.coeffs) {}
 
     /** Assignment operator*/
@@ -77,60 +72,60 @@ class isce3::core::Poly2d {
     /**Get coefficient by indices*/
     inline double getCoeff(int row, int col) const;
 
-    /**Evaluate polynomial at given y,x*/
-    double eval(double azi, double rng) const;
+    /**Evaluate polynomial at given y/azimuth/row ,x/range/col*/
+    double eval(double y, double x) const;
 
     /**Printing for debugging*/
     void printPoly() const;
 };
 
 isce3::core::Poly2d & isce3::core::Poly2d::
 operator=(const Poly2d &rhs) {
-    rangeOrder = rhs.rangeOrder;
-    azimuthOrder = rhs.azimuthOrder;
-    rangeMean = rhs.rangeMean;
-    azimuthMean = rhs.azimuthMean;
-    rangeNorm = rhs.rangeNorm;
-    azimuthNorm = rhs.azimuthNorm;
+    xOrder = rhs.xOrder;
+    yOrder = rhs.yOrder;
+    xMean = rhs.xMean;
+    yMean = rhs.yMean;
+    xNorm = rhs.xNorm;
+    yNorm = rhs.yNorm;
     coeffs = rhs.coeffs;
     return *this;
 }
 
 /**
- * @param[in] row azimuth/y index 
+ * @param[in] row azimuth/y index
  * @param[in] col range/x index
  * @param[in] val Coefficient value*/
 void isce3::core::Poly2d::
 setCoeff(int row, int col, double val) {
-    if ((row < 0) || (row > azimuthOrder)) {
-        std::string errstr = "Poly2d::setCoeff - Trying to set coefficient for row " + 
-                             std::to_string(row+1) + " out of " + 
-                             std::to_string(azimuthOrder+1);
+    if ((row < 0) || (row > yOrder)) {
+        std::string errstr = "Poly2d::setCoeff - Trying to set coefficient for row " +
+                             std::to_string(row+1) + " out of " +
+                             std::to_string(yOrder+1);
         throw std::out_of_range(errstr);
     }
-    if ((col < 0) || (col > rangeOrder)) {
+    if ((col < 0) || (col > xOrder)) {
         std::string errstr = "Poly2d::setCoeff - Trying to set coefficient for col " +
-                             std::to_string(col+1) + " out of " + std::to_string(rangeOrder+1);
+                             std::to_string(col+1) + " out of " + std::to_string(xOrder+1);
         throw std::out_of_range(errstr);
     }
-    coeffs[IDX1D(row,col,rangeOrder+1)] = val;
+    coeffs[IDX1D(row,col,xOrder+1)] = val;
 }
 
 /**
  * @param[in] row azimuth/y index
  * @param[in] col range/x index*/
 double isce3::core::Poly2d::
 getCoeff(int row, int col) const {
-    if ((row < 0) || (row > azimuthOrder)) {
+    if ((row < 0) || (row > yOrder)) {
         std::string errstr = "Poly2d::getCoeff - Trying to get coefficient for row " +
-                             std::to_string(row+1) + " out of " + 
-                             std::to_string(azimuthOrder+1);
+                             std::to_string(row+1) + " out of " +
+                             std::to_string(yOrder+1);
         throw std::out_of_range(errstr);
     }
-    if ((col < 0) || (col > rangeOrder)) {
-        std::string errstr = "Poly2d::getCoeff - Trying to get coefficient for col " + 
-                             std::to_string(col+1) + " out of " + std::to_string(rangeOrder+1);
+    if ((col < 0) || (col > xOrder)) {
+        std::string errstr = "Poly2d::getCoeff - Trying to get coefficient for col " +
+                             std::to_string(col+1) + " out of " + std::to_string(xOrder+1);
         throw std::out_of_range(errstr);
     }
-    return coeffs[IDX1D(row,col,rangeOrder+1)];
+    return coeffs[IDX1D(row,col,xOrder+1)];
 }
@@ -253,12 +253,12 @@ inline void loadFromH5(isce3::io::IGroup & group, Poly2d & poly, std::string nam
     isce3::io::loadFromH5(group, name, poly.coeffs);
 
     // Set other polynomial properties
-    poly.rangeOrder = poly.coeffs.size() - 1;
-    poly.azimuthOrder = 0;
-    poly.rangeMean = 0.0;
-    poly.azimuthMean = 0.0;
-    poly.rangeNorm = 1.0;
-    poly.azimuthNorm = 1.0;
+    poly.xOrder = poly.coeffs.size() - 1;
+    poly.yOrder = 0;
+    poly.xMean = 0.0;
+    poly.yMean = 0.0;
+    poly.xNorm = 1.0;
+    poly.yNorm = 1.0;
 }
 
 // ------------------------------------------------------------------------
 
@@ -1,9 +1,3 @@
-//
-// Author: Liang Yu
-// Copyright 2018
-//
-// NOTE: gpuOrbit used as template
-
 #include <cuda_runtime.h>
 #include <vector>
 #include <isce3/core/Constants.h>
@@ -16,72 +10,71 @@ using isce3::core::Poly2d;
 using std::vector;
 
 
-// Advanced "copy" constructor to handle deep-copying of Poly2d data (only callable by host). Owner 
-// member variable indicates that only the host-side copy of the gpuPoly2d can handle freeing the 
+// Advanced "copy" constructor to handle deep-copying of Poly2d data (only callable by host). Owner
+// member variable indicates that only the host-side copy of the gpuPoly2d can handle freeing the
 // memory (device-side copy constructor for gpuPoly2d sets owner to false)
 __host__ gpuPoly2d::gpuPoly2d(const Poly2d &poly) :
-    rangeOrder(poly.rangeOrder), 
-    azimuthOrder(poly.azimuthOrder), 
-    rangeMean(poly.rangeMean), 
-    azimuthMean(poly.azimuthMean),
-    rangeNorm(poly.rangeNorm), 
-    azimuthNorm(poly.azimuthNorm),
+    xOrder(poly.xOrder),
+    yOrder(poly.yOrder),
+    xMean(poly.xMean),
+    yMean(poly.yMean),
+    xNorm(poly.xNorm),
+    yNorm(poly.yNorm),
     owner(true)
 {
-    
+
     const int n_coeffs = poly.coeffs.size();
 
     // Malloc device-side memory (this API is host-side only)
     cudaMalloc(&coeffs, n_coeffs*sizeof(double));
 
-    // Copy OrPoly2d data to device-side memory and keep device pointer in gpuOrPoly2d object. Device-side 
+    // Copy OrPoly2d data to device-side memory and keep device pointer in gpuOrPoly2d object. Device-side
     // copy constructor simply shallow-copies the device pointers when called
     cudaMemcpy(coeffs, poly.coeffs.data(), n_coeffs*sizeof(double), cudaMemcpyHostToDevice);
 }
 
 
-// Both the host-side and device-side copies of the gpuPoly2d will call the destructor, so we have to 
-// implement a way of having an arbitrary copy on host OR device determine when to free the memory 
+// Both the host-side and device-side copies of the gpuPoly2d will call the destructor, so we have to
+// implement a way of having an arbitrary copy on host OR device determine when to free the memory
 // (since only the original host-side copy should free)
 gpuPoly2d::~gpuPoly2d() {
     if (owner) {
         cudaFree(coeffs);
     }
 }
 
-__device__ double gpuPoly2d::eval(double azi, double rng) const {
+__device__ double gpuPoly2d::eval(double y, double x) const {
 
-    double xval = (rng - rangeMean) / rangeNorm;
-    double yval = (azi - azimuthMean) / azimuthNorm;
+    double xval = (x - xMean) / xNorm;
+    double yval = (y - yMean) / yNorm;
 
     double scalex;
     double scaley = 1.;
     double val = 0.;
-    for (int i=0; i<=azimuthOrder; i++,scaley*=yval) {
+    for (int i=0; i<=yOrder; i++,scaley*=yval) {
         scalex = 1.;
-        for (int j=0; j<=rangeOrder; j++,scalex*=xval) {
-            val += scalex * scaley * coeffs[IDX1D(i,j,rangeOrder+1)];
+        for (int j=0; j<=xOrder; j++,scalex*=xval) {
+            val += scalex * scaley * coeffs[IDX1D(i,j,xOrder+1)];
         }
     }
 
     return val;
 }
 
-__global__ void eval_d(gpuPoly2d p, double azi, double rng, double *val)
+__global__ void eval_d(gpuPoly2d p, double y, double x, double *val)
 {
-    *val = p.eval(azi, rng);
+    *val = p.eval(y, x);
 }
 
-__host__ double gpuPoly2d::eval_h(double azi, double rng)
+__host__ double gpuPoly2d::eval_h(double y, double x)
 {
     double *val_d;
     double val_h;
     // use unified memory?
     cudaMalloc((double**)&val_d, sizeof(double));
     dim3 grid(1), block(1);
-    eval_d<<<grid,block>>>(*this, azi, rng, val_d);
+    eval_d<<<grid,block>>>(*this, y, x, val_d);
     cudaMemcpy(&val_h, val_d, sizeof(double), cudaMemcpyDeviceToHost);
     cudaFree(val_d);
     return val_h;
 }
-