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

sarkit_convert/sentinel.py

@@ -8,6 +8,7 @@ Convert a complex image(s) from the Sentinel SAFE to SICD(s).
 """
 
 import argparse
+import datetime
 import pathlib
 
 import dateutil.parser
@@ -138,6 +139,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 +163,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,7 +176,7 @@ def _collect_base_info(root_node):
     return base_info
 
 
-def _collect_swath_info(product_root_node):
+def _collect_swath_info(product_root_node, base_info):
     swath_info = dict()
     burst_list = product_root_node.findall("./swathTiming/burstList/burst")
 
@@ -173,12 +185,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 +251,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 +258,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"
@@ -379,7 +401,7 @@ def _collect_swath_info(product_root_node):
     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 +571,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 +606,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 +631,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 +718,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 +757,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 +792,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 +814,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 +839,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(
@@ -884,14 +943,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 +959,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
@@ -1017,7 +1090,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 +1106,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 +1157,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
@@ -1098,8 +1171,11 @@ 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"]})
 
+    sicd_xml_obj = em.SICD()
+    sicd_ew = sksicd.ElementWrapper(sicd_xml_obj)
+
     # Collection Info
-    collection_info_node = em.CollectionInfo(
+    sicd_ew["CollectionInfo"] = em.CollectionInfo(
         em.CollectorName(swath_info["collector_name"]),
         em.CoreName(burst_info["core_name"]),
         em.CollectType(base_info["collect_type"]),
@@ -1114,18 +1190,33 @@ def _create_sicd_xml(base_info, swath_info, burst_info, classification):
         em.Parameter(
             {"name": "ORBIT_SOURCE"}, swath_info["parameters"]["ORBIT_SOURCE"]
         ),
+        *(
+            [
+                em.Parameter(
+                    {"name": "BURST_ID"}, str(burst_info["parameters"]["BURST_ID"])
+                )
+            ]
+            if burst_info["parameters"].get("BURST_ID") is not None
+            else []
+        ),
+        em.Parameter(
+            {"name": "MISSION_DATA_TAKE_ID"},
+            swath_info["parameters"]["MISSION_DATA_TAKE_ID"],
+        ),
+        em.Parameter(
+            {"name": "RELATIVE_ORBIT_NUM"},
+            str(base_info["parameters"]["RELATIVE_ORBIT_NUM"]),
+        ),
     )
 
     # Image Creation
-    image_creation_node = em.ImageCreation(
+    sicd_ew["ImageCreation"] = 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__}"),
     )
 
     # Image Data
-    image_data_node = em.ImageData(
+    sicd_ew["ImageData"] = em.ImageData(
         em.PixelType(swath_info["pixel_type"]),
         em.NumRows(str(swath_info["num_rows"])),
         em.NumCols(str(swath_info["num_cols"])),
@@ -1171,7 +1262,7 @@ def _create_sicd_xml(base_info, swath_info, burst_info, classification):
         return [em.Lat(str(arr[0])), em.Lon(str(arr[1])), em.HAE(str(arr[2]))]
 
     # Geo Data
-    geo_data_node = em.GeoData(
+    sicd_ew["GeoData"] = em.GeoData(
         em.EarthModel("WGS_84"),
         em.SCP(
             em.ECF(*_make_xyz(burst_info["scp_ecf"])),
@@ -1182,7 +1273,7 @@ def _create_sicd_xml(base_info, swath_info, burst_info, classification):
     )
 
     # Grid
-    grid_node = em.Grid(
+    sicd_ew["Grid"] = em.Grid(
         em.ImagePlane(swath_info["image_plane"]),
         em.Type(swath_info["grid_type"]),
         em.TimeCOAPoly(),
@@ -1239,50 +1330,35 @@ def _create_sicd_xml(base_info, swath_info, burst_info, classification):
             ),
         ),
     )
-    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"]["TimeCOAPoly"] = burst_info["time_coa_poly_coefs"]
+    sicd_ew["Grid"]["Row"]["DeltaKCOAPoly"] = swath_info["row_deltak_coa_poly"]
+    sicd_ew["Grid"]["Col"]["DeltaKCOAPoly"] = burst_info["col_deltak_coa_poly"]
+    sicd_ew["Grid"]["Row"]["WgtFunct"] = swath_info["row_wgts"]
+    sicd_ew["Grid"]["Col"]["WgtFunct"] = swath_info["col_wgts"]
 
     # Timeline
-    timeline_node = em.Timeline(
+    sicd_ew["Timeline"] = 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.TStart(str(burst_info["ipp_set_tstart"])),
                 em.TEnd(str(burst_info["ipp_set_tend"])),
-                em.IPPStart(str(swath_info["ipp_start"])),
+                em.IPPStart(str(burst_info["ipp_set_ippstart"])),
                 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"]["IPP"]["Set"][0]["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(
+    sicd_ew["RadarCollection"] = em.RadarCollection(
         em.TxFrequency(
             em.Min(str(swath_info["tx_freq"][0])),
             em.Max(str(swath_info["tx_freq"][1])),
@@ -1321,14 +1397,19 @@ def _create_sicd_xml(base_info, swath_info, burst_info, classification):
             chan_indices = str(i)
 
     # Image Formation
-    image_formation_node = em.ImageFormation(
+    now = (
+        datetime.datetime.now(datetime.timezone.utc)
+        .isoformat(timespec="microseconds")
+        .replace("+00:00", "Z")
+    )
+    sicd_ew["ImageFormation"] = 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.TStartProc(str(burst_info["tstart_proc"])),
         em.TEndProc(str(burst_info["tend_proc"])),
         em.TxFrequencyProc(
             em.MinProc(str(swath_info["tx_freq_proc"][0])),
@@ -1339,10 +1420,14 @@ def _create_sicd_xml(base_info, swath_info, burst_info, classification):
         em.ImageBeamComp(swath_info["image_beam_comp"]),
         em.AzAutofocus(swath_info["az_autofocus"]),
         em.RgAutofocus(swath_info["rg_autofocus"]),
+        em.Processing(
+            em.Type(f"sarkit-convert {__version__} @ {now}"),
+            em.Applied("true"),
+        ),
     )
 
     # RMA
-    rma_node = em.RMA(
+    sicd_ew["RMA"] = em.RMA(
         em.RMAlgoType(swath_info["rm_algo_type"]),
         em.ImageType(swath_info["image_type"]),
         em.INCA(
@@ -1354,65 +1439,33 @@ def _create_sicd_xml(base_info, swath_info, burst_info, classification):
             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"]["INCA"]["TimeCAPoly"] = burst_info["time_ca_poly_coefs"]
+    sicd_ew["RMA"]["INCA"]["DRateSFPoly"] = burst_info["drsf_poly_coefs"]
+    sicd_ew["RMA"]["INCA"]["DopCentroidPoly"] = burst_info[
+        "doppler_centroid_poly_coefs"
+    ]
 
-    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
 
@@ -1481,12 +1534,6 @@ 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"
@@ -1498,9 +1545,8 @@ def main(args=None):
     used_filenames = set()
     for entry in files:
         product_root_node = et.parse(entry["product"]).getroot()
-        swath_info = _collect_swath_info(product_root_node)
-        burst_info_list = _collect_burst_info(product_root_node, swath_info)
-        breakpoint()
+        swath_info = _collect_swath_info(product_root_node, base_info)
+        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)
@@ -1544,7 +1590,7 @@ def main(args=None):
             metadata = sksicd.NitfMetadata(
                 xmltree=sicd.getroottree(),
                 file_header_part={
-                    "ostaid": config.ostaid,
+                    "ostaid": "ESA",
                     "ftitle": xml_helper.load("{*}CollectionInfo/{*}CoreName"),
                     "security": {
                         "clas": config.classification[0].upper(),