Expose lines per block in rdr2geo and geo2rdr (#861)

Liang Yu · GitHub Enterprise · commit 7b3c6a2ff166 · 2021-09-08T17:40:09.000-07:00
* add getters/setters for rdr2geo and geo2rdr blocksize in C++ and CUDA
* added lines per block to rdr2geo &amp; geo2rdr pybind constructors
* modified workflows for blocksize
* update yamls
* schema for rdr2geo and geo2rdr less restrictive
* default rdr2geo threshold tightended
diff --git a/cxx/isce3/geometry/Geo2rdr.h b/cxx/isce3/geometry/Geo2rdr.h
@@ -94,6 +94,13 @@ class isce3::geometry::Geo2rdr {
      */
     void numiter(int n) { _numiter = n; }
 
+    /**
+     * Set lines to be processed per block
+     *
+     * @param[in] linesPerBlock Lines to be processed per block
+     */
+    void linesPerBlock(size_t linesPerBlock) { _linesPerBlock = linesPerBlock; }
+
     /**
      * Run geo2rdr with offsets and externally created offset rasters
      *
@@ -151,6 +158,9 @@ class isce3::geometry::Geo2rdr {
     /** Return number of Newton-Raphson iterations used for processing */
     int numiter() const { return _numiter; }
 
+    /** Get linesPerBlock */
+    size_t linesPerBlock() const { return _linesPerBlock; }
+
 private:
 
     /** Print information for debugging */
diff --git a/cxx/isce3/geometry/Topo.h b/cxx/isce3/geometry/Topo.h
@@ -142,6 +142,13 @@ class isce3::geometry::Topo {
      */
     void decimaldegMargin(double deg) { _margin = deg; }
 
+    /**
+     * Set lines to be processed per block
+     *
+     * @param[in] linesPerBlock Lines to be processed per block
+     */
+    void linesPerBlock(size_t linesPerBlock) { _linesPerBlock = linesPerBlock; }
+
     // Get topo processing options
 
     /** Get distance convergence threshold used for processing */
@@ -171,6 +178,9 @@ class isce3::geometry::Topo {
     /** Get margin in decimal degrees */
     double decimaldegMargin() const { return _margin; }
 
+    /** Get linesPerBlock */
+    size_t linesPerBlock() const { return _linesPerBlock; }
+
     /** Get read-only reference to RadarGridParameters */
     const isce3::product::RadarGridParameters & radarGridParameters() const { return _radarGrid; }
 
diff --git a/python/extensions/pybind_isce3/cuda/geometry/geo2rdr.cpp b/python/extensions/pybind_isce3/cuda/geometry/geo2rdr.cpp
@@ -22,19 +22,22 @@ void addbinding(py::class_<Geo2rdr> & pyGeo2Rdr)
              const isce3::core::Ellipsoid & ellipsoid,
              const isce3::core::LUT2d<double> & doppler,
              const double threshold,
-             const int numiter)
+             const int numiter,
+             const int lines_per_block)
             {
                 auto geo2rdr_obj = Geo2rdr(radar_grid, orbit, ellipsoid, doppler);
                 geo2rdr_obj.threshold(threshold);
                 geo2rdr_obj.numiter(numiter);
+                geo2rdr_obj.linesPerBlock(lines_per_block);
                 return geo2rdr_obj;
             }),
             py::arg("radar_grid"),
             py::arg("orbit"),
             py::arg("ellipsoid"),
             py::arg("doppler") = isce3::core::LUT2d<double>(),
             py::arg("threshold") = 0.05,
-            py::arg("numiter") = 25)
+            py::arg("numiter") = 25,
+            py::arg("lines_per_block") = 1000)
         .def("geo2rdr", py::overload_cast<isce3::io::Raster &, const std::string &,
                 double, double>
                 (&Geo2rdr::geo2rdr),
@@ -52,5 +55,8 @@ void addbinding(py::class_<Geo2rdr> & pyGeo2Rdr)
         .def_property("numiter",
                 py::overload_cast<>(&Geo2rdr::numiter, py::const_),
                 py::overload_cast<int>(&Geo2rdr::numiter))
+        .def_property("lines_per_block",
+                py::overload_cast<>(&Geo2rdr::linesPerBlock, py::const_),
+                py::overload_cast<size_t>(&Geo2rdr::linesPerBlock))
         ;
 }
diff --git a/python/extensions/pybind_isce3/cuda/geometry/rdr2geo.cpp b/python/extensions/pybind_isce3/cuda/geometry/rdr2geo.cpp
@@ -25,14 +25,16 @@ void addbinding(py::class_<Topo> & pyRdr2Geo)
                                   const double threshold, const int numiter,
                                   const int extraiter,
                                   const dataInterpMethod dem_interp_method,
-                                  const int epsg_out, const bool compute_mask) {
+                                  const int epsg_out, const bool compute_mask,
+                                  const int lines_per_block) {
                 auto rdr2geo_obj = Topo(radar_grid, orbit, ellipsoid, doppler);
                 rdr2geo_obj.threshold(threshold);
                 rdr2geo_obj.numiter(numiter);
                 rdr2geo_obj.extraiter(extraiter);
                 rdr2geo_obj.demMethod(dem_interp_method);
                 rdr2geo_obj.epsgOut(epsg_out);
                 rdr2geo_obj.computeMask(compute_mask);
+                rdr2geo_obj.linesPerBlock(lines_per_block);
                 return rdr2geo_obj;
             }),
                     py::arg("radar_grid"), py::arg("orbit"),
@@ -42,7 +44,8 @@ void addbinding(py::class_<Topo> & pyRdr2Geo)
                     py::arg("extraiter") = 10,
                     py::arg("dem_interp_method") =
                             isce3::core::BIQUINTIC_METHOD,
-                    py::arg("epsg_out") = 4326, py::arg("compute_mask") = true)
+                    py::arg("epsg_out") = 4326, py::arg("compute_mask") = true,
+                    py::arg("lines_per_block") = 1000)
             .def("topo",
                     py::overload_cast<isce3::io::Raster&, const std::string&>(
                             &Topo::topo),
@@ -96,5 +99,9 @@ void addbinding(py::class_<Topo> & pyRdr2Geo)
                     py::overload_cast<int>(&Topo::epsgOut))
             .def_property("compute_mask",
                     py::overload_cast<>(&Topo::computeMask, py::const_),
-                    py::overload_cast<bool>(&Topo::computeMask));
+                    py::overload_cast<bool>(&Topo::computeMask))
+            .def_property("lines_per_block",
+                    py::overload_cast<>(&Topo::linesPerBlock, py::const_),
+                    py::overload_cast<size_t>(&Topo::linesPerBlock))
+            ;
 }
diff --git a/python/extensions/pybind_isce3/geometry/geo2rdr.cpp b/python/extensions/pybind_isce3/geometry/geo2rdr.cpp
@@ -31,19 +31,22 @@ void addbinding(py::class_<Geo2rdr> & pyGeo2Rdr)
              const isce3::core::Ellipsoid & ellipsoid,
              const isce3::core::LUT2d<double> & doppler,
              const double threshold,
-             const int numiter)
+             const int numiter,
+             const int lines_per_block)
             {
                 auto geo2rdr_obj = Geo2rdr(radar_grid, orbit, ellipsoid, doppler);
                 geo2rdr_obj.threshold(threshold);
                 geo2rdr_obj.numiter(numiter);
+                geo2rdr_obj.linesPerBlock(lines_per_block);
                 return geo2rdr_obj;
             }),
             py::arg("radar_grid"),
             py::arg("orbit"),
             py::arg("ellipsoid"),
             py::arg("doppler") = isce3::core::LUT2d<double>(),
             py::arg("threshold") = 0.05,
-            py::arg("numiter") = 25)
+            py::arg("numiter") = 25,
+            py::arg("lines_per_block") = 1000)
         .def("geo2rdr", py::overload_cast<isce3::io::Raster &, const std::string &,
                 double, double>
                 (&Geo2rdr::geo2rdr),
@@ -61,6 +64,9 @@ void addbinding(py::class_<Geo2rdr> & pyGeo2Rdr)
         .def_property("numiter",
                 py::overload_cast<>(&Geo2rdr::numiter, py::const_),
                 py::overload_cast<int>(&Geo2rdr::numiter))
+        .def_property("lines_per_block",
+                py::overload_cast<>(&Geo2rdr::linesPerBlock, py::const_),
+                py::overload_cast<size_t>(&Geo2rdr::linesPerBlock))
         ;
 }
 
diff --git a/python/extensions/pybind_isce3/geometry/rdr2geo.cpp b/python/extensions/pybind_isce3/geometry/rdr2geo.cpp
@@ -157,14 +157,16 @@ void addbinding(py::class_<Topo> & pyRdr2Geo)
                                   const double threshold, const int numiter,
                                   const int extraiter,
                                   const dataInterpMethod dem_interp_method,
-                                  const int epsg_out, const bool compute_mask) {
+                                  const int epsg_out, const bool compute_mask,
+                                  const int lines_per_block) {
                 auto rdr2geo_obj = Topo(radar_grid, orbit, ellipsoid, doppler);
                 rdr2geo_obj.threshold(threshold);
                 rdr2geo_obj.numiter(numiter);
                 rdr2geo_obj.extraiter(extraiter);
                 rdr2geo_obj.demMethod(dem_interp_method);
                 rdr2geo_obj.epsgOut(epsg_out);
                 rdr2geo_obj.computeMask(compute_mask);
+                rdr2geo_obj.linesPerBlock(lines_per_block);
                 return rdr2geo_obj;
             }),
                     py::arg("radar_grid"), py::arg("orbit"),
@@ -174,7 +176,8 @@ void addbinding(py::class_<Topo> & pyRdr2Geo)
                     py::arg("extraiter") = 10,
                     py::arg("dem_interp_method") =
                             isce3::core::BIQUINTIC_METHOD,
-                    py::arg("epsg_out") = 4326, py::arg("compute_mask") = true)
+                    py::arg("epsg_out") = 4326, py::arg("compute_mask") = true,
+                    py::arg("lines_per_block") = 1000)
             .def("topo",
                     py::overload_cast<isce3::io::Raster&, const std::string&>(
                             &Topo::topo),
@@ -228,5 +231,9 @@ void addbinding(py::class_<Topo> & pyRdr2Geo)
                     py::overload_cast<int>(&Topo::epsgOut))
             .def_property("compute_mask",
                     py::overload_cast<>(&Topo::computeMask, py::const_),
-                    py::overload_cast<bool>(&Topo::computeMask));
+                    py::overload_cast<bool>(&Topo::computeMask))
+            .def_property("lines_per_block",
+                    py::overload_cast<>(&Topo::linesPerBlock, py::const_),
+                    py::overload_cast<size_t>(&Topo::linesPerBlock))
+            ;
 }
diff --git a/python/packages/nisar/workflows/geo2rdr.py b/python/packages/nisar/workflows/geo2rdr.py
@@ -25,9 +25,9 @@ def run(cfg):
     dem_file = cfg['DynamicAncillaryFileGroup']['DEMFile']
     scratch_path = pathlib.Path(cfg['ProductPathGroup']['ScratchPath'])
     freq_pols = cfg['processing']['input_subset']['list_of_frequencies']
-
-    # Get geo2rdr params
-    geo2rdr_in = cfg['processing']['geo2rdr']
+    threshold = cfg['processing']['geo2rdr']['threshold']
+    numiter = cfg['processing']['geo2rdr']['maxiter']
+    lines_per_block = cfg['processing']['geo2rdr']['lines_per_block']
 
     # Get parameters from SLC
     slc = SLC(hdf5file=sec_hdf5)
@@ -72,8 +72,8 @@ def run(cfg):
             Geo2Rdr = isce3.geometry.Geo2Rdr
 
         geo2rdr_obj = Geo2Rdr(radar_grid, orbit, ellipsoid, doppler_grid,
-                              threshold=geo2rdr_in['threshold'],
-                              numiter=geo2rdr_in['maxiter'])
+                              threshold, numiter, lines_per_block)
+
         # Opem Topo Raster
         topo_path = pathlib.Path(cfg['processing']['geo2rdr']['topo_path'])
         rdr2geo_topo_path = topo_path / 'rdr2geo' / f'freq{freq}' / 'topo.vrt'
diff --git a/python/packages/nisar/workflows/geocode_insar.py b/python/packages/nisar/workflows/geocode_insar.py
@@ -233,7 +233,7 @@ def cpu_run(cfg, runw_hdf5, output_hdf5):
     dem_file = cfg["DynamicAncillaryFileGroup"]["DEMFile"]
     threshold_geo2rdr = cfg["processing"]["geo2rdr"]["threshold"]
     iteration_geo2rdr = cfg["processing"]["geo2rdr"]["maxiter"]
-    lines_per_block = cfg["processing"]["blocksize"]["y"]
+    lines_per_block = cfg["processing"]["geocode"]["lines_per_block"]
     dem_block_margin = cfg["processing"]["dem_margin"]
     az_looks = cfg["processing"]["crossmul"]["azimuth_looks"]
     rg_looks = cfg["processing"]["crossmul"]["range_looks"]
@@ -379,7 +379,7 @@ def gpu_run(cfg, runw_hdf5, output_hdf5):
     dem_file = cfg["DynamicAncillaryFileGroup"]["DEMFile"]
     freq_pols = cfg["processing"]["input_subset"]["list_of_frequencies"]
     geogrids = cfg["processing"]["geocode"]["geogrids"]
-    lines_per_block = cfg["processing"]["blocksize"]["y"]
+    lines_per_block = cfg["processing"]["geocode"]["lines_per_block"]
     interp_method = cfg["processing"]["geocode"]["interp_method"]
     gunw_datasets = cfg["processing"]["geocode"]["datasets"]
     az_looks = cfg["processing"]["crossmul"]["azimuth_looks"]
diff --git a/python/packages/nisar/workflows/rdr2geo.py b/python/packages/nisar/workflows/rdr2geo.py
@@ -24,6 +24,10 @@ def run(cfg):
     dem_file = cfg['DynamicAncillaryFileGroup']['DEMFile']
     scratch_path = pathlib.Path(cfg['ProductPathGroup']['ScratchPath'])
     freq_pols = cfg['processing']['input_subset']['list_of_frequencies']
+    threshold = cfg['processing']['rdr2geo']['threshold']
+    numiter = cfg['processing']['rdr2geo']['numiter']
+    extraiter = cfg['processing']['rdr2geo']['extraiter']
+    lines_per_block = cfg['processing']['rdr2geo']['lines_per_block']
 
     # get params from SLC
     slc = SLC(hdf5file=input_hdf5)
@@ -64,7 +68,10 @@ def run(cfg):
         else:
             Rdr2Geo = isce3.geometry.Rdr2Geo
 
-        rdr2geo_obj = Rdr2Geo(radargrid, orbit, ellipsoid, grid_doppler)
+        rdr2geo_obj = Rdr2Geo(radargrid, orbit, ellipsoid, grid_doppler,
+                              threshold=threshold, numiter=numiter,
+                              extraiter=extraiter,
+                              lines_per_block=lines_per_block)
 
         # run
         rdr2geo_obj.topo(dem_raster, str(rdr2geo_scratch_path))
diff --git a/share/nisar/defaults/insar.yaml b/share/nisar/defaults/insar.yaml
@@ -100,10 +100,13 @@ runconfig:
                     y_abs:
                     x_abs:
 
-            radar_grid_cubes: 
-    
+                # OPTIONAL - Set lines to be processed per block
+                lines_per_block: 1000
+
+            radar_grid_cubes:
+
                 # List of heights in meters
-                heights: 
+                heights:
 
                 # OPTIONAL - Same as the geocode group outputEPSG if not provided
                 outputEPSG:
@@ -114,8 +117,8 @@ runconfig:
                 # All postings/spacings must be > 0.
                 # ISCE3 output rasters always have North-up West-left orientation
                 output_posting:
-                    x_posting: 
-                    y_posting: 
+                    x_posting:
+                    y_posting:
 
                 # OPTIONAL - To control output grid in same units as output EPSG
                 y_snap:
@@ -124,7 +127,7 @@ runconfig:
                 x_snap:
 
                 # OPTIONAL - Can control with absolute values or with snap values
-                top_left:        
+                top_left:
                     # OPTIONAL - Set top-left y in same units as output EPSG
                     y_abs:
                     # OPTIONAL - Set top-left x in same units as output EPSG
@@ -133,15 +136,20 @@ runconfig:
                 # OPTIONAL - Can control with absolute values or with snap values
                 bottom_right:
                     y_abs:
-                    x_abs:  
+                    x_abs:
 
             geo2rdr:
                 # No topo_path provided. Default to ScratchPath.
                 threshold: 1.0e-8
                 maxiter: 25
+                lines_per_block: 1000
 
-            blocksize:
-                y: 1000
+            rdr2geo:
+                # No topo_path provided. Default to ScratchPath.
+                threshold: 1.0e-7
+                numiter: 25
+                extraiter: 10
+                lines_per_block: 1000
 
             dem_margin:
 
diff --git a/share/nisar/schemas/insar.yaml b/share/nisar/schemas/insar.yaml
@@ -54,10 +54,9 @@ runconfig:
 
             radar_grid_cubes:  include('radar_grid_cubes_options', required=False)
 
-            geo2rdr: include('geo2rdr_options', required=False)
+            rdr2geo: include('rdr2geo_options', required=False)
 
-            blocksize:
-                y: int(min=100, max=10000)
+            geo2rdr: include('geo2rdr_options', required=False)
 
             dem_margin: num(required=False)
 
@@ -430,15 +429,31 @@ radar_grid_cubes_options:
 
 geo2rdr_options:
     # Convergence threshold for geo2rdr algorithm
-    threshold: num(min=1.0e-9, max=1.0e-3, required=False)
+    threshold: num(min=0, required=False)
 
     # Maximum number of iterations
-    maxiter: int(min=10, max=50, required=False)
+    maxiter: int(min=1, required=False)
 
     # Path to rdr2geo (topo) outputs. Required only for
     # stand-alone usage of geo2rdr.py
     topo_path: str(required=False)
 
+    # Line per block to
+    lines_per_block: int(min=1, required=False)
+
+rdr2geo_options:
+    # Convergence threshold for rdr2geo algorithm
+    threshold: num(min=0, required=False)
+
+    # Maximum number of iterations
+    numiter: int(min=1, required=False)
+
+    # Extra/secondary number of iterations
+    extraiter: int(min=1, required=False)
+
+    # Line per block to
+    lines_per_block: int(min=1, required=False)
+
 
 log_nfo:
     # Path to log file
@@ -513,6 +528,9 @@ geocode_options:
         # Set bottom-right x in same units as output EPSG
         x_abs: num(required=False)
 
+    # Set lines to be processed per block
+    lines_per_block: int(min=100, max=10000, required=False)
+
 gunw_datasets:
     connectedComponents: bool(required=False)
     coherenceMagnitude: bool(required=False)
diff --git a/tests/data/insar_test.yaml b/tests/data/insar_test.yaml
@@ -103,9 +103,6 @@ runconfig:
                 threshold: 1.0e-9
                 maxiter: 25
 
-            blocksize:
-                y: 1000
-
             dem_margin: 0.1
 
             coarse_resample:
