sarkit-convert 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

sarkit_convert/sentinel.py

@@ -8,11 +8,13 @@ Convert a complex image(s) from the Sentinel SAFE to SICD(s).
 """
 
 import argparse
+import contextlib
+import datetime
+import functools
 import pathlib
 
 import dateutil.parser
-import lxml.builder
-import lxml.etree as et
+import lxml.etree
 import numpy as np
 import numpy.linalg as npl
 import numpy.polynomial.polynomial as npp
@@ -138,6 +140,20 @@ def _collect_base_info(root_node):
         # TOPSAR - closest SICD analog is Dynamic Stripmap
         base_info["mode_type"] = "DYNAMIC STRIPMAP"
 
+    relative_orbit_num = int(
+        root_node.findtext(".//{*}relativeOrbitNumber[@type='start']")
+    )
+    base_info["parameters"] = {
+        "RELATIVE_ORBIT_NUM": relative_orbit_num,
+    }
+
+    base_info["start_time_anx"] = float(
+        root_node.findtext(".//{*}acquisitionPeriod//{*}startTimeANX")
+    )
+    base_info["acq_start_str"] = root_node.findtext(
+        ".//{*}acquisitionPeriod//{*}startTime"
+    )
+
     # Image Creation
     processing = root_node.find(
         "./metadataSection/metadataObject[@ID='processing']/metadataWrap/xmlData/{*}processing",
@@ -148,9 +164,6 @@ def _collect_base_info(root_node):
         f"{software.attrib['name']} {software.attrib['version']}"
     )
     base_info["creation_date_time"] = dateutil.parser.parse(processing.attrib["stop"])
-    base_info["creation_site"] = (
-        f"{facility.attrib['name']}, {facility.attrib['site']}, {facility.attrib['country']}"
-    )
 
     # Radar Collection
     polarizations = root_node.findall(
@@ -164,6 +177,28 @@ def _collect_base_info(root_node):
     return base_info
 
 
+@functools.lru_cache
+def _window_params(window_name, coefficient):
+    window_name = window_name.upper()
+    if window_name == "HAMMING":
+        wgts = scipy.signal.windows.general_hamming(512, float(coefficient), sym=True)
+    elif window_name == "KAISER":
+        wgts = scipy.signal.windows.kaiser(512, float(coefficient), sym=True)
+    else:  # Default to UNIFORM
+        window_name = "UNIFORM"
+        coefficient = None
+        wgts = np.ones(256)
+
+    broadening_factor = utils.broadening_from_amp(wgts)
+
+    return {
+        "window_name": window_name,
+        "coefficient": coefficient,
+        "wgts": wgts,
+        "broadening_factor": broadening_factor,
+    }
+
+
 def _collect_swath_info(product_root_node):
     swath_info = dict()
     burst_list = product_root_node.findall("./swathTiming/burstList/burst")
@@ -173,12 +208,25 @@ def _collect_swath_info(product_root_node):
     swath_info["mode_id"] = product_root_node.find("./adsHeader/mode").text
     t_slice = _get_slice(product_root_node)
     swath = _get_swath(product_root_node)
+
+    mission_data_take_id = product_root_node.find("./adsHeader/missionDataTakeId").text
     swath_info["parameters"] = {
         "SLICE": t_slice,
         "SWATH": swath,
         "ORBIT_SOURCE": "SLC_INTERNAL",
+        "MISSION_DATA_TAKE_ID": mission_data_take_id,
     }
 
+    slice_list = product_root_node.findall(
+        "./imageAnnotation/imageInformation/sliceList/slice"
+    )
+    swath_info["sensing_start"] = dateutil.parser.parse(
+        slice_list[int(t_slice) - 1].find("./sensingStartTime").text
+    )
+    swath_info["sensing_stop"] = dateutil.parser.parse(
+        slice_list[int(t_slice) - 1].find("./sensingStopTime").text
+    )
+
     # Radar Collection
     center_frequency = float(
         product_root_node.find(
@@ -226,8 +274,6 @@ def _collect_swath_info(product_root_node):
             "./generalAnnotation/downlinkInformationList/downlinkInformation/prf"
         ).text
     )
-    swath_info["t_start"] = 0
-    swath_info["ipp_start"] = 0
     swath_info["ipp_poly"] = (0, swath_info["prf"])
 
     # Image Formation
@@ -235,7 +281,6 @@ def _collect_swath_info(product_root_node):
         f"{swath_info['tx_polarization']}:{swath_info['rcv_polarization']}"
     )
     swath_info["image_form_algo"] = "RMA"
-    swath_info["t_start_proc"] = 0
     swath_info["tx_freq_proc"] = swath_info["tx_freq"]
     swath_info["image_beam_comp"] = "SV"
     swath_info["az_autofocus"] = "NO"
@@ -312,20 +357,15 @@ def _collect_swath_info(product_root_node):
     range_proc = product_root_node.find(
         "./imageAnnotation/processingInformation/swathProcParamsList/swathProcParams/rangeProcessing"
     )
-    swath_info["row_window_name"] = range_proc.find("./windowType").text.upper()
-    swath_info["row_params"] = range_proc.find("./windowCoefficient").text
-    if swath_info["row_window_name"] == "HAMMING":
-        swath_info["row_wgts"] = scipy.signal.windows.general_hamming(
-            512, float(swath_info["row_params"]), sym=True
-        )
-    elif swath_info["row_window_name"] == "KAISER":
-        swath_info["row_wgts"] = scipy.signal.windows.kaiser(
-            512, float(swath_info["row_params"]), sym=True
-        )
-    else:  # Default to UNIFORM
-        swath_info["row_window_name"] = "UNIFORM"
-        swath_info["row_params"] = None
-        swath_info["row_wgts"] = np.ones(256)
+
+    window_info = _window_params(
+        range_proc.find("./windowType").text,
+        range_proc.find("./windowCoefficient").text,
+    )
+    swath_info["row_window_name"] = window_info["window_name"]
+    swath_info["row_params"] = window_info["coefficient"]
+    swath_info["row_wgts"] = window_info["wgts"]
+    swath_info["row_broadening_factor"] = window_info["broadening_factor"]
 
     swath_info["row_ss"] = (_constants.speed_of_light / 2) * delta_tau_s
     swath_info["row_sgn"] = -1
@@ -352,34 +392,29 @@ def _collect_swath_info(product_root_node):
         ).text
     )
 
-    swath_info["col_window_name"] = az_proc.find("./windowType").text.upper()
-    swath_info["col_params"] = az_proc.find("./windowCoefficient").text
-    if swath_info["col_window_name"] == "HAMMING":
-        swath_info["col_wgts"] = scipy.signal.windows.general_hamming(
-            512, float(swath_info["col_params"]), sym=True
-        )
-    elif swath_info["col_window_name"] == "KAISER":
-        swath_info["col_wgts"] = scipy.signal.windows.kaiser(
-            512, float(swath_info["col_params"]), sym=True
-        )
-    else:  # Default to UNIFORM
-        swath_info["col_window_name"] = "UNIFORM"
-        swath_info["col_params"] = None
-        swath_info["col_wgts"] = np.ones(256)
+    window_info = _window_params(
+        az_proc.find("./windowType").text, az_proc.find("./windowCoefficient").text
+    )
+    swath_info["col_window_name"] = window_info["window_name"]
+    swath_info["col_params"] = window_info["coefficient"]
+    swath_info["col_wgts"] = window_info["wgts"]
+    swath_info["col_broadening_factor"] = window_info["broadening_factor"]
 
     swath_info["col_sgn"] = -1
     swath_info["col_kctr"] = 0.0
     swath_info["col_imp_res_bw"] = dop_bw * swath_info["ss_zd_s"] / swath_info["col_ss"]
 
-    row_broadening_factor = utils.broadening_from_amp(swath_info["row_wgts"])
-    col_broadening_factor = utils.broadening_from_amp(swath_info["col_wgts"])
-    swath_info["row_imp_res_wid"] = row_broadening_factor / swath_info["row_imp_res_bw"]
-    swath_info["col_imp_res_wid"] = col_broadening_factor / swath_info["col_imp_res_bw"]
+    swath_info["row_imp_res_wid"] = (
+        swath_info["row_broadening_factor"] / swath_info["row_imp_res_bw"]
+    )
+    swath_info["col_imp_res_wid"] = (
+        swath_info["col_broadening_factor"] / swath_info["col_imp_res_bw"]
+    )
 
     return swath_info
 
 
-def _collect_burst_info(product_root_node, swath_info):
+def _collect_burst_info(product_root_node, base_info, swath_info):
     burst_list = product_root_node.findall("./swathTiming/burstList/burst")
     # parse the geolocation information - for SCP calculation
     geo_grid_point_list = product_root_node.findall(
@@ -549,7 +584,7 @@ def _collect_burst_info(product_root_node, swath_info):
         )
 
         # common use for the fitting efforts
-        poly_order = 2
+        poly_order = 4
         grid_samples = poly_order + 4
         num_rows = swath_info["num_rows"]
         num_cols = swath_info["num_cols"]
@@ -584,12 +619,13 @@ def _collect_burst_info(product_root_node, swath_info):
         demod_phase = eta_arg * f_eta_c[:, np.newaxis]
         total_phase = deramp_phase + demod_phase
 
-        phase = utils.polyfit2d(
+        phase = utils.polyfit2d_tol(
             coords_rg_2d.flatten(),
             coords_az_2d.flatten(),
             total_phase.flatten(),
             poly_order,
-            poly_order,
+            poly_order + 1,
+            1e-2,
         )
 
         # DeltaKCOAPoly is derivative of phase in azimuth/Col direction
@@ -608,12 +644,13 @@ def _collect_burst_info(product_root_node, swath_info):
         )
         time_coa_sampled = time_ca_sampled + dop_centroid_sampled / doppler_rate_sampled
 
-        burst_info["time_coa_poly_coefs"] = utils.polyfit2d(
+        burst_info["time_coa_poly_coefs"] = utils.polyfit2d_tol(
             coords_rg_2d.flatten(),
             coords_az_2d.flatten(),
             time_coa_sampled.flatten(),
             poly_order,
             poly_order,
+            1e-3,
         )
 
         full_img_verticies = np.array(
@@ -694,6 +731,28 @@ def _collect_burst_info(product_root_node, swath_info):
 
         return row_uvect_ecf, np.cross(uspz, row_uvect_ecf)
 
+    def _compute_burst_id(base_info, swath_info, burst_info):
+        """Add `burst_id` to each burst info in `swaths_info` based on DI-MPC-IPFDPM, Issue 2.5, Clause 9.25"""
+        t_orb = 12 * 24 * 3600 / 175
+        t_pre = {"IW": 2.299849, "EW": 2.299970}[swath_info["mode_id"]]
+        t_beam = {"IW": 2.758273, "EW": 3.038376}[swath_info["mode_id"]]
+
+        acq_start_utc = datetime.datetime.fromisoformat(
+            base_info["acq_start_str"]
+        ).replace(tzinfo=datetime.timezone.utc)
+        t_anx = acq_start_utc - datetime.timedelta(
+            milliseconds=base_info["start_time_anx"]
+        )
+
+        scp_tcoa = burst_info["time_coa_poly_coefs"][0, 0]
+        t_b = (
+            burst_info["collect_start"] + datetime.timedelta(seconds=scp_tcoa)
+        ).replace(tzinfo=datetime.timezone.utc)
+        delta_t_b = (t_b - t_anx).total_seconds() + (
+            base_info["parameters"]["RELATIVE_ORBIT_NUM"] - 1
+        ) * t_orb
+        return int(1 + (delta_t_b - t_pre) // t_beam)
+
     def _finalize_stripmap():
         burst_info = dict()
 
@@ -711,38 +770,34 @@ def _collect_burst_info(product_root_node, swath_info):
             (num_rows - 1, 0),
         ]
 
-        start = dateutil.parser.parse(
-            product_root_node.find(
-                "./generalAnnotation/downlinkInformationList/downlinkInformation/firstLineSensingTime"
-            ).text
-        )
-        stop = dateutil.parser.parse(
-            product_root_node.find(
-                "./generalAnnotation/downlinkInformationList/downlinkInformation/lastLineSensingTime"
-            ).text
-        )
-        slice = int(_get_slice(product_root_node))
+        t_slice = int(_get_slice(product_root_node))
         swath = _get_swath(product_root_node)
         burst_info["core_name"] = (
-            f"{start.strftime('%d%b%YT%H%M%S').upper()}_{product_root_node.find('./adsHeader/missionId').text}{product_root_node.find('./adsHeader/missionDataTakeId').text}_{slice:02d}_{swath}_01"
+            f"{swath_info['sensing_start'].strftime('%d%b%YT%H%M%S').upper()}_{product_root_node.find('./adsHeader/missionId').text}{product_root_node.find('./adsHeader/missionDataTakeId').text}_{t_slice:02d}_{swath}_01"
         )
 
-        burst_info["parameters"] = {"BURST": f"{1:d}"}
+        burst_info["parameters"] = {"BURST": f"{1:02d}"}
+
         prf = float(
             product_root_node.find(
                 "./generalAnnotation/downlinkInformationList/downlinkInformation/prf"
             ).text
         )
-        duration = (stop - start).total_seconds()
+        duration = (
+            swath_info["sensing_stop"] - swath_info["sensing_start"]
+        ).total_seconds()
 
-        burst_info["collect_start"] = start
+        burst_info["collect_start"] = swath_info["sensing_start"]
         burst_info["collect_duration"] = duration
+        burst_info["ipp_set_tstart"] = 0
         burst_info["ipp_set_tend"] = duration
+        burst_info["ipp_set_ippstart"] = 0
         burst_info["ipp_set_ippend"] = round(duration * prf) - 1
+        burst_info["tstart_proc"] = 0
         burst_info["tend_proc"] = duration
 
         burst_info["arp_poly_coefs"] = _compute_arp_poly_coefs(
-            product_root_node, start
+            product_root_node, swath_info["sensing_start"]
         ).T
 
         azimuth_time_first_line = dateutil.parser.parse(
@@ -750,9 +805,14 @@ def _collect_burst_info(product_root_node, swath_info):
                 "./imageAnnotation/imageInformation/productFirstLineUtcTime"
             ).text
         )
-        first_line_relative_start = (azimuth_time_first_line - start).total_seconds()
+        first_line_relative_start = (
+            azimuth_time_first_line - swath_info["sensing_start"]
+        ).total_seconds()
         _, _ = _calc_rma_and_grid_info(
-            swath_info, burst_info, first_line_relative_start, start
+            swath_info,
+            burst_info,
+            first_line_relative_start,
+            swath_info["sensing_start"],
         )
         burst_info["scp_ecf"], burst_info["scp_llh"] = _update_geo_data_info(
             swath_info, burst_info
@@ -767,6 +827,7 @@ def _collect_burst_info(product_root_node, swath_info):
         burst_info_list = []
 
         scps = _get_scps(swath_info, len(burst_list))
+        t_slice = int(_get_slice(product_root_node))
         for j, burst in enumerate(burst_list):
             # set preliminary geodata (required for projection)
             burst_info = dict()
@@ -791,42 +852,53 @@ def _collect_burst_info(product_root_node, swath_info):
                 (last_row, first_col),
             ]
 
-            # This is the first and last zero doppler times of the columns in the burst.
-            # Not really CollectStart and CollectDuration in SICD (first last pulse time)
-            start = dateutil.parser.parse(burst.find("./azimuthTime").text)
-            t_slice = int(_get_slice(product_root_node))
             swath = _get_swath(product_root_node)
+            # Use burst index for burst_id to maintain SARPy compatibility
             burst_info["core_name"] = (
-                f"{start.strftime('%d%b%YT%H%M%S').upper()}_{product_root_node.find('./adsHeader/missionId').text}{product_root_node.find('./adsHeader/missionDataTakeId').text}_{t_slice:02d}_{swath}_{j + 1:02d}"
+                f"{swath_info['sensing_start'].strftime('%d%b%YT%H%M%S').upper()}_{product_root_node.find('./adsHeader/missionId').text}{product_root_node.find('./adsHeader/missionDataTakeId').text}_{t_slice:02d}_{swath}_{j + 1:02d}"
+            )
+            arp_poly_coefs = _compute_arp_poly_coefs(
+                product_root_node, swath_info["sensing_start"]
             )
-
-            burst_info["parameters"] = {"BURST": f"{j + 1:d}"}
-            arp_poly_coefs = _compute_arp_poly_coefs(product_root_node, start)
             burst_info["arp_poly_coefs"] = arp_poly_coefs.T
-            early, late = _calc_rma_and_grid_info(swath_info, burst_info, 0, start)
-            new_start = start + np.timedelta64(np.int64(early * 1e6), "us")
-            duration = late - early
+
+            az_time = dateutil.parser.parse(burst.find("./azimuthTime").text)
+            first_line_relative_start = (
+                az_time - swath_info["sensing_start"]
+            ).total_seconds()
+            early, late = _calc_rma_and_grid_info(
+                swath_info,
+                burst_info,
+                first_line_relative_start,
+                swath_info["sensing_start"],
+            )
             prf = float(
                 product_root_node.find(
                     "./generalAnnotation/downlinkInformationList/downlinkInformation/prf"
                 ).text
             )
-            burst_info["collect_start"] = new_start
-            burst_info["collect_duration"] = duration
-            burst_info["ipp_set_tend"] = duration
-            burst_info["ipp_set_ippend"] = round(duration * prf) - 1
-            burst_info["tend_proc"] = duration
-
-            # adjust time offset
-            burst_info["time_coa_poly_coefs"][0, 0] -= early
-            burst_info["time_ca_poly_coefs"][0] -= early
-
-            arp_poly_coefs = np.array(
-                [
-                    _shift(arp_poly_coefs[i], t_0=-early)
-                    for i in range(len(arp_poly_coefs))
-                ]
-            )
+            burst_info["collect_start"] = swath_info["sensing_start"]
+            burst_info["collect_duration"] = (
+                swath_info["sensing_stop"] - swath_info["sensing_start"]
+            ).total_seconds()
+            burst_info["ipp_set_tstart"] = early
+            burst_info["ipp_set_tend"] = late
+            burst_info["ipp_set_ippstart"] = round(early * prf)
+            burst_info["ipp_set_ippend"] = round(late * prf) - 1
+            burst_info["tstart_proc"] = early
+            burst_info["tend_proc"] = late
+
+            if burst.find("./burstId") is not None:
+                burst_id = burst.findtext("./burstId")
+            else:
+                burst_id = _compute_burst_id(base_info, swath_info, burst_info)
+
+            # Keep BURST as the index to maintain SARPy compatibility
+            burst_info["parameters"] = {
+                "BURST": f"{j + 1:02d}",
+                "BURST_ID": burst_id,
+            }
+
             burst_info["arp_poly_coefs"] = arp_poly_coefs.T
 
             burst_info["scp_ecf"], burst_info["scp_llh"] = _update_geo_data_info(
@@ -848,7 +920,7 @@ def _collect_burst_info(product_root_node, swath_info):
 
 def _calc_radiometric_info(cal_file_name, swath_info, burst_info_list):
     """Compute radiometric polys"""
-    cal_root_node = et.parse(cal_file_name).getroot()
+    cal_root_node = lxml.etree.parse(cal_file_name).getroot()
     cal_vector_list = cal_root_node.findall(
         "./{*}calibrationVectorList/{*}calibrationVector"
     )
@@ -884,14 +956,15 @@ def _calc_radiometric_info(cal_file_name, swath_info, burst_info_list):
     gamma = 1.0 / (gamma * gamma)
 
     for idx, burst_info in enumerate(burst_info_list):
-        valid_lines = (line >= idx * lines_per_burst) & (
-            line < (idx + 1) * lines_per_burst
-        )
+        burst_first_line = idx * lines_per_burst
+        burst_last_line = burst_first_line + lines_per_burst
+        valid_lines = (line >= burst_first_line) & (line < burst_last_line)
         valid_count = np.sum(valid_lines)
         if valid_count == 0:
             # this burst contained no useful calibration data
             return
 
+        max_poly_order = 4
         first_row = swath_info["first_row"]
         first_col = swath_info["first_col"]
         scp_row = swath_info["scp_pixel"][0]
@@ -899,32 +972,45 @@ def _calc_radiometric_info(cal_file_name, swath_info, burst_info_list):
         row_ss = swath_info["row_ss"]
         col_ss = swath_info["col_ss"]
         coords_rg = (pixel[valid_lines] + first_row - scp_row) * row_ss
-        coords_az = (line[valid_lines] + first_col - scp_col) * col_ss
+        coords_az = (
+            line[valid_lines] + first_col - scp_col - burst_first_line
+        ) * col_ss
         # NB: coords_rg = (valid_count, M) and coords_az = (valid_count, )
         coords_az = np.repeat(coords_az, pixel.shape[1])
         if valid_count > 1:
             coords_az = coords_az.reshape((valid_count, -1))
+        max_poly_order_rg = min(max_poly_order, len(coords_rg) - 1)
+        max_poly_order_az = min(max_poly_order, len(coords_az) - 1)
 
-        burst_info["radiometric"]["sigma_zero_poly_coefs"] = utils.polyfit2d(
+        sigma_vals = sigma[valid_lines, :].flatten()
+        sigma_tol = np.maximum(np.std(sigma_vals) * 1e-1, np.mean(sigma_vals) * 1e-2)
+        burst_info["radiometric"]["sigma_zero_poly_coefs"] = utils.polyfit2d_tol(
             coords_rg.flatten(),
             coords_az.flatten(),
-            sigma[valid_lines, :].flatten(),
-            2,
-            2,
+            sigma_vals,
+            max_poly_order_rg,
+            max_poly_order_az,
+            sigma_tol,
         )
-        burst_info["radiometric"]["beta_zero_poly_coefs"] = utils.polyfit2d(
+        beta_vals = beta[valid_lines, :].flatten()
+        beta_tol = np.maximum(np.std(beta_vals) * 1e-1, np.mean(beta_vals) * 1e-2)
+        burst_info["radiometric"]["beta_zero_poly_coefs"] = utils.polyfit2d_tol(
             coords_rg.flatten(),
             coords_az.flatten(),
-            beta[valid_lines, :].flatten(),
-            2,
-            2,
+            beta_vals,
+            max_poly_order_rg,
+            max_poly_order_az,
+            beta_tol,
         )
-        burst_info["radiometric"]["gamma_zero_poly_coefs"] = utils.polyfit2d(
+        gamma_vals = gamma[valid_lines, :].flatten()
+        gamma_tol = np.maximum(np.std(gamma_vals) * 1e-1, np.mean(gamma_vals) * 1e-2)
+        burst_info["radiometric"]["gamma_zero_poly_coefs"] = utils.polyfit2d_tol(
             coords_rg.flatten(),
             coords_az.flatten(),
-            gamma[valid_lines, :].flatten(),
-            2,
-            2,
+            gamma_vals,
+            max_poly_order_rg,
+            max_poly_order_az,
+            gamma_tol,
         )
 
         range_weight_f = azimuth_weight_f = 1.0
@@ -950,7 +1036,7 @@ def _calc_radiometric_info(cal_file_name, swath_info, burst_info_list):
 
 def _calc_noise_level_info(noise_file_name, swath_info, burst_info_list):
     """Compute noise poly"""
-    noise_root_node = et.parse(noise_file_name).getroot()
+    noise_root_node = lxml.etree.parse(noise_file_name).getroot()
     mode_id = swath_info["mode_id"]
     lines_per_burst = swath_info["num_cols"]
     range_size_pixels = swath_info["num_rows"]
@@ -1017,7 +1103,7 @@ def _calc_noise_level_info(noise_file_name, swath_info, burst_info_list):
     else:
         azimuth_line, azimuth_noise = None, None
 
-    rg_poly_order = min(5, range_pixel[0].size - 1)
+    rg_poly_order = min(4, range_pixel[0].size - 1)
     first_row = swath_info["first_row"]
     first_col = swath_info["first_col"]
     scp_row = swath_info["scp_pixel"][0]
@@ -1033,12 +1119,13 @@ def _calc_noise_level_info(noise_file_name, swath_info, burst_info_list):
 
             coords_az_2d, coords_rg_2d = np.meshgrid(coords_az, coords_rg)
 
-            noise_poly = utils.polyfit2d(
+            noise_poly = utils.polyfit2d_tol(
                 coords_rg_2d.flatten(),
                 coords_az_2d.flatten(),
                 np.array(range_noise).flatten(),
                 rg_poly_order,
                 az_poly_order,
+                1e-2,
             )
         else:
             # TOPSAR has single LUT per burst
@@ -1083,9 +1170,8 @@ def _calc_noise_level_info(noise_file_name, swath_info, burst_info_list):
 
 
 def _complete_filename(swath_info, burst_info, filename_template):
-    core_name = burst_info["core_name"]
-    burst = core_name[-2:]
     swath = swath_info["parameters"]["SWATH"]
+    burst = burst_info["parameters"]["BURST"]
     polarization = swath_info["tx_rcv_polarization_proc"].replace(":", "")
     formatted_name = filename_template.name.format(
         swath=swath, burst=burst, pol=polarization
@@ -1096,335 +1182,244 @@ def _complete_filename(swath_info, burst_info, filename_template):
 
 
 def _create_sicd_xml(base_info, swath_info, burst_info, classification):
-    em = lxml.builder.ElementMaker(namespace=NSMAP["sicd"], nsmap={None: NSMAP["sicd"]})
-
-    # Collection Info
-    collection_info_node = em.CollectionInfo(
-        em.CollectorName(swath_info["collector_name"]),
-        em.CoreName(burst_info["core_name"]),
-        em.CollectType(base_info["collect_type"]),
-        em.RadarMode(
-            em.ModeType(base_info["mode_type"]),
-            em.ModeID(swath_info["mode_id"]),
-        ),
-        em.Classification(classification),
-        em.Parameter({"name": "SLICE"}, swath_info["parameters"]["SLICE"]),
-        em.Parameter({"name": "BURST"}, burst_info["parameters"]["BURST"]),
-        em.Parameter({"name": "SWATH"}, swath_info["parameters"]["SWATH"]),
-        em.Parameter(
-            {"name": "ORBIT_SOURCE"}, swath_info["parameters"]["ORBIT_SOURCE"]
-        ),
-    )
-
-    # Image Creation
-    image_creation_node = em.ImageCreation(
-        em.Application(base_info["creation_application"]),
-        em.DateTime(base_info["creation_date_time"].strftime("%Y-%m-%dT%H:%M:%SZ")),
-        em.Site(base_info["creation_site"]),
-        em.Profile(f"sarkit-convert {__version__}"),
+    sicd_xml_obj = lxml.etree.Element(
+        f"{{{NSMAP['sicd']}}}SICD", nsmap={None: NSMAP["sicd"]}
     )
+    sicd_ew = sksicd.ElementWrapper(sicd_xml_obj)
 
-    # Image Data
-    image_data_node = em.ImageData(
-        em.PixelType(swath_info["pixel_type"]),
-        em.NumRows(str(swath_info["num_rows"])),
-        em.NumCols(str(swath_info["num_cols"])),
-        em.FirstRow(str(swath_info["first_row"])),
-        em.FirstCol(str(swath_info["first_col"])),
-        em.FullImage(
-            em.NumRows(str(swath_info["num_rows"])),
-            em.NumCols(str(swath_info["num_cols"])),
-        ),
-        em.SCPPixel(
-            em.Row(str(swath_info["scp_pixel"][0])),
-            em.Col(str(swath_info["scp_pixel"][1])),
-        ),
-        em.ValidData(
-            {"size": "4"},
-            em.Vertex(
-                {"index": "1"},
-                em.Row(str(burst_info["valid_data"][0][0])),
-                em.Col(str(burst_info["valid_data"][0][1])),
-            ),
-            em.Vertex(
-                {"index": "2"},
-                em.Row(str(burst_info["valid_data"][1][0])),
-                em.Col(str(burst_info["valid_data"][1][1])),
-            ),
-            em.Vertex(
-                {"index": "3"},
-                em.Row(str(burst_info["valid_data"][2][0])),
-                em.Col(str(burst_info["valid_data"][2][1])),
-            ),
-            em.Vertex(
-                {"index": "4"},
-                em.Row(str(burst_info["valid_data"][3][0])),
-                em.Col(str(burst_info["valid_data"][3][1])),
-            ),
-        ),
+    # Collection Info
+    parameter = [
+        ("SLICE", swath_info["parameters"]["SLICE"]),
+        ("BURST", burst_info["parameters"]["BURST"]),
+        ("SWATH", swath_info["parameters"]["SWATH"]),
+        ("ORBIT_SOURCE", swath_info["parameters"]["ORBIT_SOURCE"]),
+    ]
+    if burst_info["parameters"].get("BURST_ID") is not None:
+        parameter.append(("BURST_ID", str(burst_info["parameters"]["BURST_ID"])))
+    parameter.extend(
+        [
+            ("MISSION_DATA_TAKE_ID", swath_info["parameters"]["MISSION_DATA_TAKE_ID"]),
+            ("RELATIVE_ORBIT_NUM", str(base_info["parameters"]["RELATIVE_ORBIT_NUM"])),
+        ]
     )
+    sicd_ew["CollectionInfo"] = {
+        "CollectorName": swath_info["collector_name"],
+        "CoreName": burst_info["core_name"],
+        "CollectType": base_info["collect_type"],
+        "RadarMode": {
+            "ModeType": base_info["mode_type"],
+            "ModeID": swath_info["mode_id"],
+        },
+        "Classification": classification,
+        "Parameter": parameter,
+    }
+    sicd_ew["ImageCreation"] = {
+        "Application": base_info["creation_application"],
+        "DateTime": base_info["creation_date_time"],
+    }
+    sicd_ew["ImageData"] = {
+        "PixelType": swath_info["pixel_type"],
+        "NumRows": swath_info["num_rows"],
+        "NumCols": swath_info["num_cols"],
+        "FirstRow": swath_info["first_row"],
+        "FirstCol": swath_info["first_col"],
+        "FullImage": {
+            "NumRows": swath_info["num_rows"],
+            "NumCols": swath_info["num_cols"],
+        },
+        "SCPPixel": swath_info["scp_pixel"],
+        "ValidData": burst_info["valid_data"],
+    }
 
-    def _make_xyz(arr):
-        return [em.X(str(arr[0])), em.Y(str(arr[1])), em.Z(str(arr[2]))]
-
-    def __make_llh(arr):
-        return [em.Lat(str(arr[0])), em.Lon(str(arr[1])), em.HAE(str(arr[2]))]
-
-    # Geo Data
-    geo_data_node = em.GeoData(
-        em.EarthModel("WGS_84"),
-        em.SCP(
-            em.ECF(*_make_xyz(burst_info["scp_ecf"])),
-            em.LLH(*__make_llh(burst_info["scp_llh"])),
-        ),
-        em.ImageCorners(),
-        em.ValidData(),
-    )
+    sicd_ew["GeoData"] = {
+        "EarthModel": "WGS_84",
+        "SCP": {
+            "ECF": burst_info["scp_ecf"],
+            "LLH": burst_info["scp_llh"],
+        },
+    }
 
-    # Grid
-    grid_node = em.Grid(
-        em.ImagePlane(swath_info["image_plane"]),
-        em.Type(swath_info["grid_type"]),
-        em.TimeCOAPoly(),
-        em.Row(
-            em.UVectECF(*_make_xyz(burst_info["row_uvect_ecf"])),
-            em.SS(str(swath_info["row_ss"])),
-            em.ImpRespWid(str(swath_info["row_imp_res_wid"])),
-            em.Sgn(str(swath_info["row_sgn"])),
-            em.ImpRespBW(str(swath_info["row_imp_res_bw"])),
-            em.KCtr(str(swath_info["row_kctr"])),
-            em.DeltaK1(str(burst_info["row_delta_k1"])),
-            em.DeltaK2(str(burst_info["row_delta_k2"])),
-            em.DeltaKCOAPoly(),
-            em.WgtType(
-                em.WindowName(
-                    str(swath_info["row_window_name"]),
-                ),
-                *(
-                    [
-                        em.Parameter(
-                            {"name": "COEFFICIENT"},
-                            str(swath_info["row_params"]),
-                        )
-                    ]
-                    if swath_info["row_params"] is not None
-                    else []
-                ),
-            ),
-        ),
-        em.Col(
-            em.UVectECF(*_make_xyz(burst_info["col_uvect_ecf"])),
-            em.SS(str(swath_info["col_ss"])),
-            em.ImpRespWid(str(swath_info["col_imp_res_wid"])),
-            em.Sgn(str(swath_info["col_sgn"])),
-            em.ImpRespBW(str(swath_info["col_imp_res_bw"])),
-            em.KCtr(str(swath_info["col_kctr"])),
-            em.DeltaK1(str(burst_info["col_delta_k1"])),
-            em.DeltaK2(str(burst_info["col_delta_k2"])),
-            em.DeltaKCOAPoly(),
-            em.WgtType(
-                em.WindowName(
-                    str(swath_info["col_window_name"]),
-                ),
-                *(
-                    [
-                        em.Parameter(
-                            {"name": "COEFFICIENT"},
-                            str(swath_info["col_params"]),
-                        )
-                    ]
-                    if swath_info["col_params"] is not None
-                    else []
-                ),
-            ),
-        ),
-    )
-    sksicd.Poly2dType().set_elem(
-        grid_node.find("./{*}TimeCOAPoly"), burst_info["time_coa_poly_coefs"]
-    )
-    sksicd.Poly2dType().set_elem(
-        grid_node.find("./{*}Row/{*}DeltaKCOAPoly"), swath_info["row_deltak_coa_poly"]
-    )
-    sksicd.Poly2dType().set_elem(
-        grid_node.find("./{*}Col/{*}DeltaKCOAPoly"), burst_info["col_deltak_coa_poly"]
-    )
-    wgtfunc = em.WgtFunct()
-    sksicd.TRANSCODERS["Grid/Row/WgtFunct"].set_elem(wgtfunc, swath_info["row_wgts"])
-    grid_node.find("./{*}Row").append(wgtfunc)
-    wgtfunc = em.WgtFunct()
-    sksicd.TRANSCODERS["Grid/Col/WgtFunct"].set_elem(wgtfunc, swath_info["col_wgts"])
-    grid_node.find("./{*}Col").append(wgtfunc)
+    sicd_ew["Grid"] = {
+        "ImagePlane": swath_info["image_plane"],
+        "Type": swath_info["grid_type"],
+        "TimeCOAPoly": burst_info["time_coa_poly_coefs"],
+        "Row": {
+            "UVectECF": burst_info["row_uvect_ecf"],
+            "SS": swath_info["row_ss"],
+            "ImpRespWid": swath_info["row_imp_res_wid"],
+            "Sgn": swath_info["row_sgn"],
+            "ImpRespBW": swath_info["row_imp_res_bw"],
+            "KCtr": swath_info["row_kctr"],
+            "DeltaK1": burst_info["row_delta_k1"],
+            "DeltaK2": burst_info["row_delta_k2"],
+            "DeltaKCOAPoly": swath_info["row_deltak_coa_poly"],
+            "WgtType": {
+                "WindowName": swath_info["row_window_name"],
+            },
+            "WgtFunct": swath_info["row_wgts"],
+        },
+        "Col": {
+            "UVectECF": burst_info["col_uvect_ecf"],
+            "SS": swath_info["col_ss"],
+            "ImpRespWid": swath_info["col_imp_res_wid"],
+            "Sgn": swath_info["col_sgn"],
+            "ImpRespBW": swath_info["col_imp_res_bw"],
+            "KCtr": swath_info["col_kctr"],
+            "DeltaK1": burst_info["col_delta_k1"],
+            "DeltaK2": burst_info["col_delta_k2"],
+            "DeltaKCOAPoly": burst_info["col_deltak_coa_poly"],
+            "WgtType": {
+                "WindowName": swath_info["col_window_name"],
+            },
+            "WgtFunct": swath_info["col_wgts"],
+        },
+    }
+    if swath_info["row_params"] is not None:
+        sicd_ew["Grid"]["Row"]["WgtType"]["Parameter"] = [
+            ("COEFFICIENT", str(swath_info["row_params"]))
+        ]
+    if swath_info["col_params"] is not None:
+        sicd_ew["Grid"]["Col"]["WgtType"]["Parameter"] = [
+            ("COEFFICIENT", str(swath_info["col_params"]))
+        ]
 
-    # Timeline
-    timeline_node = em.Timeline(
-        em.CollectStart(burst_info["collect_start"].strftime("%Y-%m-%dT%H:%M:%S.%fZ")),
-        em.CollectDuration(str(burst_info["collect_duration"])),
-        em.IPP(
-            {"size": "1"},
-            em.Set(
-                {"index": "1"},
-                em.TStart(str(swath_info["t_start"])),
-                em.TEnd(str(burst_info["ipp_set_tend"])),
-                em.IPPStart(str(swath_info["ipp_start"])),
-                em.IPPEnd(str(burst_info["ipp_set_ippend"])),
-                em.IPPPoly(),
-            ),
-        ),
-    )
-    sksicd.PolyType().set_elem(
-        timeline_node.find("./{*}IPP/{*}Set/{*}IPPPoly"), swath_info["ipp_poly"]
-    )
+    sicd_ew["Timeline"] = {
+        "CollectStart": burst_info["collect_start"],
+        "CollectDuration": burst_info["collect_duration"],
+        "IPP": {
+            "@size": 1,
+            "Set": [
+                {
+                    "@index": 1,
+                    "TStart": burst_info["ipp_set_tstart"],
+                    "TEnd": burst_info["ipp_set_tend"],
+                    "IPPStart": burst_info["ipp_set_ippstart"],
+                    "IPPEnd": burst_info["ipp_set_ippend"],
+                    "IPPPoly": swath_info["ipp_poly"],
+                }
+            ],
+        },
+    }
 
-    # Position
-    position_node = em.Position(em.ARPPoly())
-    sksicd.XyzPolyType().set_elem(
-        position_node.find("./{*}ARPPoly"), burst_info["arp_poly_coefs"]
-    )
+    sicd_ew["Position"]["ARPPoly"] = burst_info["arp_poly_coefs"]
 
     # Radar Collection
-    radar_collection_node = em.RadarCollection(
-        em.TxFrequency(
-            em.Min(str(swath_info["tx_freq"][0])),
-            em.Max(str(swath_info["tx_freq"][1])),
-        ),
-        em.Waveform(
-            {"size": f"{len(swath_info['rcv_window_length'])}"},
-            *[
-                em.WFParameters(
-                    {"index": str(i)},
-                    em.TxPulseLength(str(swath_info["tx_pulse_length"])),
-                    em.TxRFBandwidth(str(swath_info["tx_rf_bw"])),
-                    em.TxFreqStart(str(swath_info["tx_freq_start"])),
-                    em.TxFMRate(str(swath_info["tx_fm_rate"])),
-                    em.RcvWindowLength(str(swl)),
-                    em.ADCSampleRate(str(swath_info["adc_sample_rate"])),
-                )
+    sicd_ew["RadarCollection"] = {
+        "TxFrequency": {
+            "Min": swath_info["tx_freq"][0],
+            "Max": swath_info["tx_freq"][1],
+        },
+        "Waveform": {
+            "@size": len(swath_info["rcv_window_length"]),
+            "WFParameters": [
+                {
+                    "@index": i,
+                    "TxPulseLength": swath_info["tx_pulse_length"],
+                    "TxRFBandwidth": swath_info["tx_rf_bw"],
+                    "TxFreqStart": swath_info["tx_freq_start"],
+                    "TxFMRate": swath_info["tx_fm_rate"],
+                    "RcvWindowLength": swl,
+                    "ADCSampleRate": swath_info["adc_sample_rate"],
+                }
                 for i, swl in enumerate(swath_info["rcv_window_length"], start=1)
             ],
-        ),
-        em.TxPolarization(swath_info["tx_polarization"]),
-        em.RcvChannels(
-            {"size": f"{len(base_info['tx_rcv_polarization'])}"},
-            *[
-                em.ChanParameters(
-                    {"index": str(i)},
-                    em.TxRcvPolarization(entry),
-                )
+        },
+        "TxPolarization": swath_info["tx_polarization"],
+        "RcvChannels": {
+            "@size": len(base_info["tx_rcv_polarization"]),
+            "ChanParameters": [
+                {
+                    "@index": i,
+                    "TxRcvPolarization": entry,
+                }
                 for i, entry in enumerate(base_info["tx_rcv_polarization"], start=1)
             ],
-        ),
-    )
+        },
+    }
 
-    chan_indices = None
+    chan_index = None
     for i, pol in enumerate(base_info["tx_rcv_polarization"], start=1):
         if pol == swath_info["tx_rcv_polarization_proc"]:
-            chan_indices = str(i)
+            chan_index = str(i)
 
     # Image Formation
-    image_formation_node = em.ImageFormation(
-        em.RcvChanProc(
-            em.NumChanProc("1"),
-            em.PRFScaleFactor("1"),
-            em.ChanIndex(chan_indices),
-        ),
-        em.TxRcvPolarizationProc(swath_info["tx_rcv_polarization_proc"]),
-        em.TStartProc(str(swath_info["t_start_proc"])),
-        em.TEndProc(str(burst_info["tend_proc"])),
-        em.TxFrequencyProc(
-            em.MinProc(str(swath_info["tx_freq_proc"][0])),
-            em.MaxProc(str(swath_info["tx_freq_proc"][1])),
-        ),
-        em.ImageFormAlgo(swath_info["image_form_algo"]),
-        em.STBeamComp(swath_info["st_beam_comp"]),
-        em.ImageBeamComp(swath_info["image_beam_comp"]),
-        em.AzAutofocus(swath_info["az_autofocus"]),
-        em.RgAutofocus(swath_info["rg_autofocus"]),
+    now = (
+        datetime.datetime.now(datetime.timezone.utc)
+        .isoformat(timespec="microseconds")
+        .replace("+00:00", "Z")
     )
+    sicd_ew["ImageFormation"] = {
+        "RcvChanProc": {
+            "NumChanProc": 1,
+            "PRFScaleFactor": 1,
+            "ChanIndex": [chan_index],
+        },
+        "TxRcvPolarizationProc": swath_info["tx_rcv_polarization_proc"],
+        "TStartProc": burst_info["tstart_proc"],
+        "TEndProc": burst_info["tend_proc"],
+        "TxFrequencyProc": {
+            "MinProc": swath_info["tx_freq_proc"][0],
+            "MaxProc": swath_info["tx_freq_proc"][1],
+        },
+        "ImageFormAlgo": swath_info["image_form_algo"],
+        "STBeamComp": swath_info["st_beam_comp"],
+        "ImageBeamComp": swath_info["image_beam_comp"],
+        "AzAutofocus": swath_info["az_autofocus"],
+        "RgAutofocus": swath_info["rg_autofocus"],
+        "Processing": [
+            {
+                "Type": f"sarkit-convert {__version__} @ {now}",
+                "Applied": True,
+            },
+        ],
+    }
 
-    # RMA
-    rma_node = em.RMA(
-        em.RMAlgoType(swath_info["rm_algo_type"]),
-        em.ImageType(swath_info["image_type"]),
-        em.INCA(
-            em.TimeCAPoly(),
-            em.R_CA_SCP(str(swath_info["r_ca_scp"])),
-            em.FreqZero(str(swath_info["freq_zero"])),
-            em.DRateSFPoly(),
-            em.DopCentroidPoly(),
-            em.DopCentroidCOA(swath_info["dop_centroid_coa"]),
-        ),
-    )
-    sksicd.PolyType().set_elem(
-        rma_node.find("./{*}INCA/{*}TimeCAPoly"), burst_info["time_ca_poly_coefs"]
-    )
-    sksicd.Poly2dType().set_elem(
-        rma_node.find("./{*}INCA/{*}DRateSFPoly"), burst_info["drsf_poly_coefs"]
-    )
-    sksicd.Poly2dType().set_elem(
-        rma_node.find("./{*}INCA/{*}DopCentroidPoly"),
-        burst_info["doppler_centroid_poly_coefs"],
-    )
+    sicd_ew["RMA"] = {
+        "RMAlgoType": swath_info["rm_algo_type"],
+        "ImageType": swath_info["image_type"],
+        "INCA": {
+            "TimeCAPoly": burst_info["time_ca_poly_coefs"],
+            "R_CA_SCP": swath_info["r_ca_scp"],
+            "FreqZero": swath_info["freq_zero"],
+            "DRateSFPoly": burst_info["drsf_poly_coefs"],
+            "DopCentroidPoly": burst_info["doppler_centroid_poly_coefs"],
+            "DopCentroidCOA": swath_info["dop_centroid_coa"],
+        },
+    }
 
-    sicd_xml_obj = em.SICD(
-        collection_info_node,
-        image_creation_node,
-        image_data_node,
-        geo_data_node,
-        grid_node,
-        timeline_node,
-        position_node,
-        radar_collection_node,
-        image_formation_node,
-        rma_node,
-    )
-    breakpoint()
     # Add Radiometric after Sentinel baseline processing calibration update on 25 Nov 2015.
     if "radiometric" in burst_info:
         # Radiometric
-        radiometric_node = em.Radiometric(
-            em.NoiseLevel(
-                em.NoiseLevelType(burst_info["radiometric"]["noise_level_type"]),
-                em.NoisePoly(),
-            ),
-            em.RCSSFPoly(),
-            em.SigmaZeroSFPoly(),
-            em.BetaZeroSFPoly(),
-            em.GammaZeroSFPoly(),
-        )
-        sksicd.Poly2dType().set_elem(
-            radiometric_node.find("./{*}NoiseLevel/{*}NoisePoly"),
-            burst_info["radiometric"]["noise_poly_coefs"],
-        )
-        sksicd.Poly2dType().set_elem(
-            radiometric_node.find("./{*}RCSSFPoly"),
-            burst_info["radiometric"]["rcs_sf_poly_coefs"],
-        )
-        sksicd.Poly2dType().set_elem(
-            radiometric_node.find("./{*}SigmaZeroSFPoly"),
-            burst_info["radiometric"]["sigma_zero_poly_coefs"],
-        )
-        sksicd.Poly2dType().set_elem(
-            radiometric_node.find("./{*}BetaZeroSFPoly"),
-            burst_info["radiometric"]["beta_zero_poly_coefs"],
-        )
-        sksicd.Poly2dType().set_elem(
-            radiometric_node.find("./{*}GammaZeroSFPoly"),
-            burst_info["radiometric"]["gamma_zero_poly_coefs"],
-        )
-
-        sicd_xml_obj.find("{*}RMA").addprevious(radiometric_node)
+        sicd_ew["Radiometric"]["NoiseLevel"]["NoiseLevelType"] = burst_info[
+            "radiometric"
+        ]["noise_level_type"]
+        sicd_ew["Radiometric"]["NoiseLevel"]["NoisePoly"] = burst_info["radiometric"][
+            "noise_poly_coefs"
+        ]
+        sicd_ew["Radiometric"]["RCSSFPoly"] = burst_info["radiometric"][
+            "rcs_sf_poly_coefs"
+        ]
+        sicd_ew["Radiometric"]["SigmaZeroSFPoly"] = burst_info["radiometric"][
+            "sigma_zero_poly_coefs"
+        ]
+        sicd_ew["Radiometric"]["BetaZeroSFPoly"] = burst_info["radiometric"][
+            "beta_zero_poly_coefs"
+        ]
+        sicd_ew["Radiometric"]["GammaZeroSFPoly"] = burst_info["radiometric"][
+            "gamma_zero_poly_coefs"
+        ]
 
     return sicd_xml_obj
 
 
-def _update_geo_data(xml_helper):
+def _update_geo_data(sicd_ew):
     # Update ImageCorners
-    num_rows = xml_helper.load("./{*}ImageData/{*}NumRows")
-    num_cols = xml_helper.load("./{*}ImageData/{*}NumCols")
-    row_ss = xml_helper.load("./{*}Grid/{*}Row/{*}SS")
-    col_ss = xml_helper.load("./{*}Grid/{*}Col/{*}SS")
-    scp_pixel = xml_helper.load("./{*}ImageData/{*}SCPPixel")
-    scp_ecf = xml_helper.load("./{*}GeoData/{*}SCP/{*}ECF")
+    num_rows = sicd_ew["ImageData"]["NumRows"]
+    num_cols = sicd_ew["ImageData"]["NumCols"]
+    row_ss = sicd_ew["Grid"]["Row"]["SS"]
+    col_ss = sicd_ew["Grid"]["Col"]["SS"]
+    scp_pixel = sicd_ew["ImageData"]["SCPPixel"]
+    scp_ecf = sicd_ew["GeoData"]["SCP"]["ECF"]
     image_grid_locations = (
         np.array(
             [
@@ -1438,27 +1433,39 @@ def _update_geo_data(xml_helper):
     ) * [row_ss, col_ss]
 
     icp_ecef, _, _ = sksicd.image_to_ground_plane(
-        xml_helper.element_tree,
+        sicd_ew.elem.getroottree(),
         image_grid_locations,
         scp_ecf,
         sarkit.wgs84.up(sarkit.wgs84.cartesian_to_geodetic(scp_ecf)),
     )
     icp_llh = sarkit.wgs84.cartesian_to_geodetic(icp_ecef)
-    xml_helper.set("./{*}GeoData/{*}ImageCorners", icp_llh[:, :2])
-    xml_helper.set("./{*}GeoData/{*}ValidData", icp_llh[:, :2])
+    sicd_ew["GeoData"]["ImageCorners"] = icp_llh[:, :2]
+    sicd_ew["GeoData"]["ValidData"] = icp_llh[:, :2]
 
 
-def _update_rniirs_info(xml_helper):
-    em = lxml.builder.ElementMaker(namespace=NSMAP["sicd"], nsmap={None: NSMAP["sicd"]})
-    info_density, predicted_rniirs = utils.get_rniirs_estimate(xml_helper)
-    collection_info_node = xml_helper.element_tree.find("./{*}CollectionInfo")
+def _update_rniirs_info(sicd_ew):
+    info_density, predicted_rniirs = utils.get_rniirs_estimate(sicd_ew)
+    sicd_ew["CollectionInfo"].add(
+        "Parameter", ("INFORMATION_DENSITY", f"{info_density:.2G}")
+    )
+    sicd_ew["CollectionInfo"].add(
+        "Parameter", ("PREDICTED_RNIIRS", f"{predicted_rniirs:.1f}")
+    )
 
-    param_node = em.Parameter({"name": "INFORMATION_DENSITY"}, f"{info_density:0.2G}")
-    collection_info_node.append(param_node)
-    param_node = em.Parameter({"name": "PREDICTED_RNIIRS"}, f"{predicted_rniirs:0.1f}")
-    collection_info_node.append(param_node)
 
-    return
+@contextlib.contextmanager
+def uint_tiff():
+    """Overwrite SAMPLEFORMAT to force TIFFILE not to upcast from complex int16 to complex64
+
+    Per S1-RS-MDA-52-7441 (Sentinel-1 Product Specification) Table 6-13:
+    "Interpretation of pixel format. Set to 5 (complex signed integer, 'int16') for SLC products"
+    """
+    oldformat = tifffile.SAMPLEFORMAT
+    tifffile.SAMPLEFORMAT = lambda _: oldformat.UINT  # treat as UINT
+    try:
+        yield
+    finally:
+        tifffile.SAMPLEFORMAT = oldformat
 
 
 def main(args=None):
@@ -1481,83 +1488,80 @@ def main(args=None):
         type=pathlib.Path,
         help="path of the output SICD file. The strings '{swath}', '{burst}', '{pol}' will be replaced as appropriate for multiple images",
     )
-    parser.add_argument(
-        "--ostaid",
-        type=str,
-        help="content of the originating station ID (OSTAID) field of the NITF header",
-        default="Unknown",
-    )
     config = parser.parse_args(args)
 
     manifest_filename = config.safe_product_folder / "manifest.safe"
 
-    manifest_root = et.parse(manifest_filename).getroot()
+    manifest_root = lxml.etree.parse(manifest_filename).getroot()
     base_info = _collect_base_info(manifest_root)
     files = _get_file_sets(config.safe_product_folder, manifest_root)
 
     used_filenames = set()
     for entry in files:
-        product_root_node = et.parse(entry["product"]).getroot()
+        product_root_node = lxml.etree.parse(entry["product"]).getroot()
         swath_info = _collect_swath_info(product_root_node)
-        burst_info_list = _collect_burst_info(product_root_node, swath_info)
-        breakpoint()
+        burst_info_list = _collect_burst_info(product_root_node, base_info, swath_info)
         if base_info["creation_date_time"].date() >= np.datetime64("2015-11-25"):
             [burst_info.update({"radiometric": {}}) for burst_info in burst_info_list]
             _calc_radiometric_info(entry["calibration"], swath_info, burst_info_list)
             _calc_noise_level_info(entry["noise"], swath_info, burst_info_list)
 
         # Grab the data and write the files
-        with tifffile.TiffFile(entry["data"]) as tif:
+        # Overwrite SAMPLEFORMAT to force TIFFILE not to upcast from complex int16 to complex64
+        # Treat as uint32 and handle the conversion later
+        assert swath_info["pixel_type"] != "RE16I_IM16I", (
+            "pixel handling assumes 'RE16I_IM16I'"
+        )
+        with uint_tiff(), tifffile.TiffFile(entry["data"]) as tif:
             image = tif.asarray().T
             image_width = tif.pages[0].tags.values()[0].value
         begin_col = 0
         for burst_info in burst_info_list:
-            sicd = _create_sicd_xml(
+            sicd_xml_obj = _create_sicd_xml(
                 base_info, swath_info, burst_info, config.classification.upper()
             )
+            sicd_ew = sksicd.ElementWrapper(sicd_xml_obj)
             # Add SCPCOA node
-            scp_coa = sksicd.compute_scp_coa(sicd.getroottree())
-            sicd.find("./{*}ImageFormation").addnext(scp_coa)
-            xml_helper = sksicd.XmlHelper(et.ElementTree(sicd))
+            sicd_ew["SCPCOA"] = sksicd.compute_scp_coa(sicd_xml_obj.getroottree())
             # Update ImageCorners and ValidData
-            _update_geo_data(xml_helper)
+            _update_geo_data(sicd_ew)
 
             # RNIIRS calcs require radiometric info
             if "radiometric" in burst_info:
-                _update_rniirs_info(xml_helper)
+                _update_rniirs_info(sicd_ew)
 
             # Check for XML consistency
-            sicd_con = sarkit.verification.SicdConsistency(sicd)
+            sicd_con = sarkit.verification.SicdConsistency(sicd_ew.elem)
             sicd_con.check()
             sicd_con.print_result(fail_detail=True)
 
-            end_col = begin_col + xml_helper.load("{*}ImageData/{*}NumCols")
+            end_col = begin_col + sicd_ew["ImageData"]["NumCols"]
             subset = (slice(0, image_width, 1), slice(begin_col, end_col, 1))
             begin_col = end_col
-            image_subset = image[subset]
+            image_subset = np.ascontiguousarray(image[subset])
             pixel_type = swath_info["pixel_type"]
-            view_dtype = sksicd.PIXEL_TYPES[pixel_type]["dtype"]
-            complex_data = np.empty(image_subset.shape, dtype=view_dtype)
-            complex_data["real"] = image_subset.real.astype(np.int16)
-            complex_data["imag"] = image_subset.imag.astype(np.int16)
+            view_dtype = sksicd.PIXEL_TYPES[pixel_type]["dtype"].newbyteorder(
+                image_subset.dtype.byteorder
+            )
+            complex_data = image_subset.view(view_dtype)
 
             metadata = sksicd.NitfMetadata(
-                xmltree=sicd.getroottree(),
+                xmltree=sicd_ew.elem.getroottree(),
                 file_header_part={
-                    "ostaid": config.ostaid,
-                    "ftitle": xml_helper.load("{*}CollectionInfo/{*}CoreName"),
+                    "ostaid": "ESA",
+                    "ftitle": sicd_ew["CollectionInfo"]["CoreName"],
                     "security": {
                         "clas": config.classification[0].upper(),
                         "clsy": "US",
                     },
                 },
                 im_subheader_part={
-                    "iid2": xml_helper.load("{*}CollectionInfo/{*}CoreName"),
+                    "iid2": sicd_ew["CollectionInfo"]["CoreName"],
                     "security": {
                         "clas": config.classification[0].upper(),
                         "clsy": "US",
                     },
-                    "isorce": xml_helper.load("{*}CollectionInfo/{*}CollectorName"),
+                    "isorce": sicd_ew["CollectionInfo"]["CollectorName"],
                 },
                 de_subheader_part={
                     "security": {