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

sarkit_convert/{csk.py → cosmo.py}

@@ -17,11 +17,15 @@ metadata that would predict the complex data characteristics
 
 import argparse
 import contextlib
+import datetime
 import pathlib
 
+import astropy.coordinates as apcoord
+import astropy.units as apu
+import astropy.utils
 import dateutil.parser
 import h5py
-import lxml.builder
+import lxml.etree
 import numpy as np
 import numpy.linalg as npl
 import numpy.polynomial.polynomial as npp
@@ -30,9 +34,13 @@ import sarkit.verification
 import sarkit.wgs84
 import scipy.constants
 import scipy.optimize
+import scipy.spatial.transform
 
+from sarkit_convert import __version__
 from sarkit_convert import _utils as utils
 
+astropy.utils.iers.conf.autodownload = False
+
 NSMAP = {
     "sicd": "urn:SICD:1.4.0",
 }
@@ -130,7 +138,6 @@ def hdf5_to_sicd(
     h5_filename,
     sicd_filename,
     classification,
-    ostaid,
     img_str,
     chan_index,
     tx_polarizations,
@@ -141,8 +148,10 @@ def hdf5_to_sicd(
         mission_id = h5_attrs["Mission ID"]
         if mission_id == "CSG":
             dataset_str = "IMG"
+            burst_str = "B0001"
         else:
             dataset_str = "SBI"
+            burst_str = "B001"
         sample_data_h5_path = f"{img_str}/{dataset_str}"
         sample_data_shape = h5file[sample_data_h5_path].shape
         sample_data_dtype = h5file[sample_data_h5_path].dtype
@@ -171,7 +180,6 @@ def hdf5_to_sicd(
 
     # Creation Info
     creation_time = dateutil.parser.parse(h5_attrs["Product Generation UTC"])
-    creation_site = h5_attrs["Processing Centre"]
     l0_ver = h5_attrs.get("L0 Software Version", "NONE")
     l1_ver = h5_attrs.get("L1A Software Version", "NONE")
     creation_application = f"L0: {l0_ver}, L1: {l1_ver}"
@@ -311,31 +319,34 @@ def hdf5_to_sicd(
     range_rate_per_hz = -scipy.constants.speed_of_light / (2 * center_frequency)
     range_rate = doppler_centroid * range_rate_per_hz
     range_rate_rate = doppler_rate * range_rate_per_hz
-    doppler_centroid_poly = utils.polyfit2d(
+    doppler_centroid_poly = utils.polyfit2d_tol(
         grid_coords[..., 0].flatten(),
         grid_coords[..., 1].flatten(),
         doppler_centroid.flatten(),
         4,
         4,
+        1e-2,
     )
-    doppler_rate_poly = utils.polyfit2d(
+    doppler_rate_poly = utils.polyfit2d_tol(
         grid_coords[..., 0].flatten(),
         grid_coords[..., 1].flatten(),
         doppler_rate.flatten(),
         4,
         4,
+        1e-3,
     )
     time_ca_samps = time_coords[..., 1] - start_minus_ref
     time_ca_poly = npp.polyfit(
         grid_coords[..., 1].flatten(), time_ca_samps.flatten(), 1
     )
     time_coa_samps = time_ca_samps + range_rate / range_rate_rate
-    time_coa_poly = utils.polyfit2d(
+    time_coa_poly = utils.polyfit2d_tol(
         grid_coords[..., 0].flatten(),
         grid_coords[..., 1].flatten(),
         time_coa_samps.flatten(),
         4,
         4,
+        1e-3,
     )
 
     range_ca = time_coords[..., 0] * scipy.constants.speed_of_light / 2
@@ -344,12 +355,13 @@ def hdf5_to_sicd(
         axis=0,
     )
     drsf = range_rate_rate * range_ca / speed_ca**2
-    drsf_poly = utils.polyfit2d(
+    drsf_poly = utils.polyfit2d_tol(
         grid_coords[..., 0].flatten(),
         grid_coords[..., 1].flatten(),
         drsf.flatten(),
         4,
         4,
+        1e-6,
     )
 
     llh_ddm = h5_attrs["Scene Centre Geodetic Coordinates"]
@@ -398,53 +410,198 @@ def hdf5_to_sicd(
     uspz = spz / npl.norm(spz)
     u_col = np.cross(uspz, u_row)
 
-    # Build XML
-    sicd = lxml.builder.ElementMaker(
-        namespace=NSMAP["sicd"], nsmap={None: NSMAP["sicd"]}
-    )
-    collection_info = sicd.CollectionInfo(
-        sicd.CollectorName(collector_name),
-        sicd.CoreName(core_name),
-        sicd.CollectType("MONOSTATIC"),
-        sicd.RadarMode(sicd.ModeType(radar_mode_type), sicd.ModeID(radar_mode_id)),
-        sicd.Classification(classification),
-    )
-    image_creation = sicd.ImageCreation(
-        sicd.Application(creation_application),
-        sicd.DateTime(creation_time.isoformat() + "Z"),
-        sicd.Site(creation_site),
-    )
-    image_data = sicd.ImageData(
-        sicd.PixelType(pixel_type),
-        sicd.NumRows(str(num_rows)),
-        sicd.NumCols(str(num_cols)),
-        sicd.FirstRow(str(first_row)),
-        sicd.FirstCol(str(first_col)),
-        sicd.FullImage(sicd.NumRows(str(num_rows)), sicd.NumCols(str(num_cols))),
-        sicd.SCPPixel(sicd.Row(str(scp_pixel[0])), sicd.Col(str(scp_pixel[1]))),
-    )
-
-    def make_xyz(arr):
-        return [sicd.X(str(arr[0])), sicd.Y(str(arr[1])), sicd.Z(str(arr[2]))]
-
-    def make_llh(arr):
-        return [sicd.Lat(str(arr[0])), sicd.Lon(str(arr[1])), sicd.HAE(str(arr[2]))]
-
-    def make_ll(arr):
-        return [sicd.Lat(str(arr[0])), sicd.Lon(str(arr[1]))]
-
-    # Placeholder locations
-    geo_data = sicd.GeoData(
-        sicd.EarthModel("WGS_84"),
-        sicd.SCP(sicd.ECF(*make_xyz(scp_ecf)), sicd.LLH(*make_llh(scp_llh))),
-        sicd.ImageCorners(
-            sicd.ICP({"index": "1:FRFC"}, *make_ll([0, 0])),
-            sicd.ICP({"index": "2:FRLC"}, *make_ll([0, 0])),
-            sicd.ICP({"index": "3:LRLC"}, *make_ll([0, 0])),
-            sicd.ICP({"index": "4:LRFC"}, *make_ll([0, 0])),
-        ),
+    # Antenna
+    attitude_quaternion = np.roll(h5_attrs["Attitude Quaternions"], -1, axis=1)
+    attitude_times = h5_attrs["Attitude Times"]
+    attitude_utcs = [
+        ref_time + datetime.timedelta(seconds=attitude_time)
+        for attitude_time in attitude_times
+    ]
+
+    inertial_position = h5_attrs["Inertial Satellite Position"]
+    inertial_velocity = h5_attrs["Inertial Satellite Velocity"]
+    inertial_acceleration = h5_attrs["Inertial Satellite Acceleration"]
+    eci_apc_poly = utils.fit_state_vectors(
+        (0, (collection_stop_time - collection_start_time).total_seconds()),
+        h5_attrs["State Vectors Times"]
+        - (collection_start_time - ref_time).total_seconds(),
+        inertial_position,
+        inertial_velocity,
+        inertial_acceleration,
+        order=5,
+    )
+
+    def get_nadir_plane_at_time(time):
+        obstime = collection_start_time + datetime.timedelta(seconds=time)
+        eci_pos = npp.polyval(time, eci_apc_poly)
+        eci_vel = npp.polyval(time, npp.polyder(eci_apc_poly))
+
+        # Derived from https://adsabs.harvard.edu/full/2006ESASP.606E..35C, Section 3
+        z_sc = -eci_pos / np.linalg.norm(eci_pos)
+        y_sc_dir = np.cross(z_sc, eci_vel)
+        y_sc = y_sc_dir / np.linalg.norm(y_sc_dir)
+        x_sc = np.cross(y_sc, z_sc)
+        eci_2_ecf = np.array(
+            [
+                apcoord.GCRS(
+                    apcoord.CartesianRepresentation(1, 0, 0, unit=apu.m),
+                    obstime=obstime,
+                )
+                .transform_to(apcoord.ITRS(obstime=obstime))
+                .data.xyz.value,
+                apcoord.GCRS(
+                    apcoord.CartesianRepresentation(0, 1, 0, unit=apu.m),
+                    obstime=obstime,
+                )
+                .transform_to(apcoord.ITRS(obstime=obstime))
+                .data.xyz.value,
+                apcoord.GCRS(
+                    apcoord.CartesianRepresentation(0, 0, 1, unit=apu.m),
+                    obstime=obstime,
+                )
+                .transform_to(apcoord.ITRS(obstime=obstime))
+                .data.xyz.value,
+            ]
+        )
+        x_sc = x_sc @ eci_2_ecf
+        y_sc = y_sc @ eci_2_ecf
+        z_sc = z_sc @ eci_2_ecf
+        return np.array([x_sc, y_sc, z_sc])
+
+    rel_att_times = np.array(
+        [(att_utc - collection_start_time).total_seconds() for att_utc in attitude_utcs]
+    )
+    good_indices = np.where(
+        np.logical_and(
+            np.less(-60, rel_att_times),
+            np.less(rel_att_times, 60 + collection_duration),
+        )
+    )
+    good_times = rel_att_times[good_indices]
+    good_att_quat = attitude_quaternion[good_indices]
+    nadir_planes = [get_nadir_plane_at_time(time) for time in good_times]
+    body_frame = np.array(
+        [
+            scipy.spatial.transform.Rotation.from_quat(att_quat)
+            .inv()
+            .apply(nadir_plane.T)
+            .T
+            for att_quat, nadir_plane in zip(good_att_quat, nadir_planes)
+        ]
+    )
+
+    ux_rot = body_frame[:, 0, :]
+    uy_rot = body_frame[:, 1, :]
+
+    ant_x_dir_poly = utils.fit_state_vectors(
+        (0, (collection_stop_time - collection_start_time).total_seconds()),
+        good_times,
+        ux_rot,
+        None,
+        None,
+        order=4,
+    )
+    ant_y_dir_poly = utils.fit_state_vectors(
+        (0, (collection_stop_time - collection_start_time).total_seconds()),
+        good_times,
+        uy_rot,
+        None,
+        None,
+        order=4,
     )
 
+    freq_zero = h5_attrs["Radar Frequency"]
+    antenna_beam_elevation = h5_attrs[img_str]["Antenna Beam Elevation"]
+    fit_order = 4
+
+    def fit_steering(code_change_lines, dcs):
+        if len(code_change_lines) > 1:
+            times = code_change_lines / prf
+            return npp.polyfit(times, dcs, fit_order)
+        else:
+            return np.array(dcs).reshape((1,))
+
+    if radar_mode_type != "STRIPMAP":
+        azimuth_ramp_code_change_lines = h5_attrs[img_str][burst_str][
+            "Azimuth Ramp Code Change Lines"
+        ]
+        azimuth_steering = h5_attrs[img_str][burst_str]["Azimuth Steering"]
+        elevation_ramp_code_change_lines = h5_attrs[img_str][burst_str][
+            "Elevation Ramp Code Change Lines"
+        ]
+        elevation_steering = h5_attrs[img_str][burst_str]["Elevation Steering"]
+        eb_dcx = np.sin(np.deg2rad(azimuth_steering))
+        eb_dcx_poly = fit_steering(azimuth_ramp_code_change_lines, eb_dcx)
+        eb_dcy = -np.sin(np.deg2rad(antenna_beam_elevation + elevation_steering))
+        eb_dcy_poly = fit_steering(elevation_ramp_code_change_lines, eb_dcy)
+    else:
+        eb_dcx_poly = [0.0]
+        eb_dcy_poly = [-np.sin(np.deg2rad(antenna_beam_elevation))]
+
+    antenna_az_gains = h5_attrs[img_str]["Azimuth Antenna Pattern Gains"]
+    antenna_az_origin = h5_attrs[img_str]["Azimuth Antenna Pattern Origin"]
+    antenna_az_spacing = h5_attrs[img_str]["Azimuth Antenna Pattern Resolution"]
+
+    antenna_rg_gains = h5_attrs[img_str]["Range Antenna Pattern Gains"]
+    antenna_rg_origin = h5_attrs[img_str]["Range Antenna Pattern Origin"]
+    antenna_rg_spacing = h5_attrs[img_str]["Range Antenna Pattern Resolution"]
+
+    def fit_gains(origin, spacing, gains):
+        fit_limit = -9
+        array_mask = gains > fit_limit
+        dcs = np.sin(np.deg2rad(origin + spacing * np.arange(len(gains))))
+        return npp.polyfit(dcs[array_mask], gains[array_mask], fit_order)
+
+    antenna_array_gain = np.zeros((fit_order + 1, fit_order + 1), dtype=float)
+    antenna_array_gain[0, :] = fit_gains(
+        antenna_rg_origin, antenna_rg_spacing, antenna_rg_gains
+    )
+    antenna_array_gain[:, 0] = fit_gains(
+        antenna_az_origin, antenna_az_spacing, antenna_az_gains
+    )
+    antenna_array_gain[0, 0] = 0.0
+
+    # Build XML
+    sicd_xml_obj = lxml.etree.Element(
+        f"{{{NSMAP['sicd']}}}SICD", nsmap={None: NSMAP["sicd"]}
+    )
+    sicd_ew = sksicd.ElementWrapper(sicd_xml_obj)
+
+    sicd_ew["CollectionInfo"] = {
+        "CollectorName": collector_name,
+        "CoreName": core_name,
+        "CollectType": "MONOSTATIC",
+        "RadarMode": {
+            "ModeType": radar_mode_type,
+            "ModeID": radar_mode_id,
+        },
+        "Classification": classification,
+    }
+    sicd_ew["ImageCreation"] = {
+        "Application": creation_application,
+        "DateTime": creation_time,
+    }
+    sicd_ew["ImageData"] = {
+        "PixelType": pixel_type,
+        "NumRows": num_rows,
+        "NumCols": num_cols,
+        "FirstRow": first_row,
+        "FirstCol": first_col,
+        "FullImage": {
+            "NumRows": num_rows,
+            "NumCols": num_cols,
+        },
+        "SCPPixel": scp_pixel,
+    }
+
+    sicd_ew["GeoData"] = {
+        "EarthModel": "WGS_84",
+        "SCP": {
+            "ECF": scp_ecf,
+            "LLH": scp_llh,
+        },
+    }
+
     dc_sgn = np.sign(-doppler_rate_poly[0, 0])
     col_deltakcoa_poly = (
         -look * dc_sgn * doppler_centroid_poly * intervals[1] / spacings[1]
@@ -468,168 +625,180 @@ def hdf5_to_sicd(
     col_window_name = h5_attrs["Azimuth Focusing Weighting Function"]
     col_window_coeff = h5_attrs["Azimuth Focusing Weighting Coefficient"]
 
-    grid = sicd.Grid(
-        sicd.ImagePlane("SLANT"),
-        sicd.Type("RGZERO"),
-        sicd.TimeCOAPoly(),
-        sicd.Row(
-            sicd.UVectECF(*make_xyz(u_row)),
-            sicd.SS(str(spacings[0])),
-            sicd.ImpRespWid(str(row_wid)),
-            sicd.Sgn("-1"),
-            sicd.ImpRespBW(str(row_bw)),
-            sicd.KCtr(str(center_frequency / (scipy.constants.speed_of_light / 2))),
-            sicd.DeltaK1(str(-row_bw / 2)),
-            sicd.DeltaK2(str(row_bw / 2)),
-            sicd.DeltaKCOAPoly(),
-            sicd.WgtType(
-                sicd.WindowName(row_window_name),
-                sicd.Parameter({"name": "COEFFICIENT"}, str(row_window_coeff)),
-            ),
-        ),
-        sicd.Col(
-            sicd.UVectECF(*make_xyz(u_col)),
-            sicd.SS(str(spacings[1])),
-            sicd.ImpRespWid(str(col_wid)),
-            sicd.Sgn("-1"),
-            sicd.ImpRespBW(str(col_bw)),
-            sicd.KCtr("0"),
-            sicd.DeltaK1(str(dk1)),
-            sicd.DeltaK2(str(dk2)),
-            sicd.DeltaKCOAPoly(),
-            sicd.WgtType(
-                sicd.WindowName(col_window_name),
-                sicd.Parameter({"name": "COEFFICIENT"}, str(col_window_coeff)),
-            ),
-        ),
-    )
-    sksicd.Poly2dType().set_elem(grid.find("./{*}TimeCOAPoly"), time_coa_poly)
-    sksicd.Poly2dType().set_elem(grid.find("./{*}Row/{*}DeltaKCOAPoly"), [[0]])
-    sksicd.Poly2dType().set_elem(
-        grid.find("./{*}Col/{*}DeltaKCOAPoly"), col_deltakcoa_poly
-    )
+    sicd_ew["Grid"] = {
+        "ImagePlane": "SLANT",
+        "Type": "RGZERO",
+        "TimeCOAPoly": time_coa_poly,
+        "Row": {
+            "UVectECF": u_row,
+            "SS": spacings[0],
+            "ImpRespWid": row_wid,
+            "Sgn": -1,
+            "ImpRespBW": row_bw,
+            "KCtr": center_frequency / (scipy.constants.speed_of_light / 2),
+            "DeltaK1": -row_bw / 2,
+            "DeltaK2": row_bw / 2,
+            "DeltaKCOAPoly": [[0.0]],
+            "WgtType": {
+                "WindowName": row_window_name,
+                "Parameter": [("COEFFICIENT", str(row_window_coeff))],
+            },
+        },
+        "Col": {
+            "UVectECF": u_col,
+            "SS": spacings[1],
+            "ImpRespWid": col_wid,
+            "Sgn": -1,
+            "ImpRespBW": col_bw,
+            "KCtr": 0.0,
+            "DeltaK1": dk1,
+            "DeltaK2": dk2,
+            "DeltaKCOAPoly": col_deltakcoa_poly,
+            "WgtType": {
+                "WindowName": col_window_name,
+                "Parameter": [("COEFFICIENT", str(col_window_coeff))],
+            },
+        },
+    }
     rcs_row_sf = None
     rcs_col_sf = None
     if row_window_name == "HAMMING":
         wgts = scipy.signal.windows.general_hamming(512, row_window_coeff, sym=True)
-        wgtfunc = sicd.WgtFunct()
-        sksicd.TRANSCODERS["Grid/Row/WgtFunct"].set_elem(wgtfunc, wgts)
-        grid.find("./{*}Row").append(wgtfunc)
+        sicd_ew["Grid"]["Row"]["WgtFunct"] = wgts
         row_broadening_factor = utils.broadening_from_amp(wgts)
         row_wid = row_broadening_factor / row_bw
-        sksicd.DblType().set_elem(grid.find("./{*}Row/{*}ImpRespWid"), row_wid)
+        sicd_ew["Grid"]["Row"]["ImpRespWid"] = row_wid
         rcs_row_sf = 1 + np.var(wgts) / np.mean(wgts) ** 2
     if col_window_name == "HAMMING":
         wgts = scipy.signal.windows.general_hamming(512, col_window_coeff, sym=True)
-        wgtfunc = sicd.WgtFunct()
-        sksicd.TRANSCODERS["Grid/Col/WgtFunct"].set_elem(wgtfunc, wgts)
-        grid.find("./{*}Col").append(wgtfunc)
+        sicd_ew["Grid"]["Col"]["WgtFunct"] = wgts
         col_broadening_factor = utils.broadening_from_amp(wgts)
         col_wid = col_broadening_factor / col_bw
-        sksicd.DblType().set_elem(grid.find("./{*}Col/{*}ImpRespWid"), col_wid)
+        sicd_ew["Grid"]["Col"]["ImpRespWid"] = col_wid
         rcs_col_sf = 1 + np.var(wgts) / np.mean(wgts) ** 2
 
-    timeline = sicd.Timeline(
-        sicd.CollectStart(collection_start_time.isoformat() + "Z"),
-        sicd.CollectDuration(str(collection_duration)),
-        sicd.IPP(
-            {"size": "1"},
-            sicd.Set(
-                {"index": "1"},
-                sicd.TStart(str(0)),
-                sicd.TEnd(str(num_pulses / prf)),
-                sicd.IPPStart(str(0)),
-                sicd.IPPEnd(str(num_pulses - 1)),
-                sicd.IPPPoly(),
-            ),
-        ),
-    )
-    sksicd.PolyType().set_elem(timeline.find("./{*}IPP/{*}Set/{*}IPPPoly"), [0, prf])
+    sicd_ew["Timeline"] = {
+        "CollectStart": collection_start_time,
+        "CollectDuration": collection_duration,
+        "IPP": {
+            "@size": 1,
+            "Set": [
+                {
+                    "@index": 1,
+                    "TStart": 0,
+                    "TEnd": num_pulses / prf,
+                    "IPPStart": 0,
+                    "IPPEnd": num_pulses - 1,
+                    "IPPPoly": [0, prf],
+                }
+            ],
+        },
+    }
 
-    position = sicd.Position(sicd.ARPPoly())
-    sksicd.XyzPolyType().set_elem(position.find("./{*}ARPPoly"), apc_poly)
+    sicd_ew["Position"]["ARPPoly"] = apc_poly
 
-    rcv_channels = sicd.RcvChannels(
-        {"size": str(len(tx_rcv_pols))},
-    )
+    chan_parameters = []
     for ndx, tx_rcv_pol in enumerate(tx_rcv_pols):
-        rcv_channels.append(
-            sicd.ChanParameters(
-                {"index": str(ndx + 1)}, sicd.TxRcvPolarization(tx_rcv_pol)
-            )
+        chan_parameters.append(
+            {
+                "@index": ndx + 1,
+                "TxRcvPolarization": tx_rcv_pol,
+            }
         )
 
-    radar_collection = sicd.RadarCollection(
-        sicd.TxFrequency(sicd.Min(str(tx_freq_min)), sicd.Max(str(tx_freq_max))),
-        sicd.Waveform(
-            {"size": "1"},
-            sicd.WFParameters(
-                {"index": "1"},
-                sicd.TxPulseLength(str(tx_pulse_length)),
-                sicd.TxRFBandwidth(str(tx_rf_bw)),
-                sicd.TxFreqStart(str(tx_freq_start)),
-                sicd.TxFMRate(str(tx_fm_rate)),
-                sicd.RcvWindowLength(str(rcv_window_length)),
-                sicd.ADCSampleRate(str(adc_sample_rate)),
-            ),
-        ),
-        sicd.TxPolarization(tx_polarization),
-        rcv_channels,
-    )
+    sicd_ew["RadarCollection"] = {
+        "TxFrequency": {
+            "Min": tx_freq_min,
+            "Max": tx_freq_max,
+        },
+        "Waveform": {
+            "@size": 1,
+            "WFParameters": [
+                {
+                    "@index": 1,
+                    "TxPulseLength": tx_pulse_length,
+                    "TxRFBandwidth": tx_rf_bw,
+                    "TxFreqStart": tx_freq_start,
+                    "TxFMRate": tx_fm_rate,
+                    "RcvWindowLength": rcv_window_length,
+                    "ADCSampleRate": adc_sample_rate,
+                }
+            ],
+        },
+        "TxPolarization": tx_polarization,
+        "RcvChannels": {
+            "@size": len(tx_rcv_pols),
+            "ChanParameters": chan_parameters,
+        },
+    }
     if len(tx_polarizations) > 1:
-        radar_collection.find("./{*}TxPolarization").text = "SEQUENCE"
-        tx_sequence = sicd.TxSequence({"size": str(len(tx_polarizations))})
+        sicd_ew["RadarCollection"]["TxPolarization"] = "SEQUENCE"
+        tx_steps = []
         for ndx, tx_pol in enumerate(tx_polarizations):
-            tx_sequence.append(
-                sicd.TxStep({"index": str(ndx + 1)}, sicd.TxPolarization(tx_pol))
+            tx_steps.append(
+                {
+                    "@index": ndx + 1,
+                    "TxPolarization": tx_pol,
+                }
             )
-        rcv_channels.addprevious(tx_sequence)
-
-    image_formation = sicd.ImageFormation(
-        sicd.RcvChanProc(sicd.NumChanProc("1"), sicd.ChanIndex(str(chan_index))),
-        sicd.TxRcvPolarizationProc(tx_rcv_polarization),
-        sicd.TStartProc(str(0)),
-        sicd.TEndProc(str(collection_duration)),
-        sicd.TxFrequencyProc(
-            sicd.MinProc(str(tx_freq_min)), sicd.MaxProc(str(tx_freq_max))
-        ),
-        sicd.ImageFormAlgo("RMA"),
-        sicd.STBeamComp("NO"),
-        sicd.ImageBeamComp("SV"),
-        sicd.AzAutofocus("NO"),
-        sicd.RgAutofocus("NO"),
-    )
-
-    rma = sicd.RMA(
-        sicd.RMAlgoType("OMEGA_K"),
-        sicd.ImageType("INCA"),
-        sicd.INCA(
-            sicd.TimeCAPoly(),
-            sicd.R_CA_SCP(str(scp_rca)),
-            sicd.FreqZero(str(center_frequency)),
-            sicd.DRateSFPoly(),
-            sicd.DopCentroidPoly(),
-        ),
-    )
-    sksicd.PolyType().set_elem(rma.find("./{*}INCA/{*}TimeCAPoly"), time_ca_poly)
-    sksicd.Poly2dType().set_elem(rma.find("./{*}INCA/{*}DRateSFPoly"), drsf_poly)
-    sksicd.Poly2dType().set_elem(
-        rma.find("./{*}INCA/{*}DopCentroidPoly"), doppler_centroid_poly
-    )
-    sicd_xml_obj = sicd.SICD(
-        collection_info,
-        image_creation,
-        image_data,
-        geo_data,
-        grid,
-        timeline,
-        position,
-        radar_collection,
-        image_formation,
-        rma,
-    )
+        sicd_ew["RadarCollection"]["TxSequence"] = {
+            "@size": len(tx_polarizations),
+            "TxStep": tx_steps,
+        }
+
+    now = (
+        datetime.datetime.now(datetime.timezone.utc)
+        .isoformat(timespec="microseconds")
+        .replace("+00:00", "Z")
+    )
+    sicd_ew["ImageFormation"] = {
+        "RcvChanProc": {
+            "NumChanProc": 1,
+            "ChanIndex": [chan_index],
+        },
+        "TxRcvPolarizationProc": tx_rcv_polarization,
+        "TStartProc": 0,
+        "TEndProc": collection_duration,
+        "TxFrequencyProc": {
+            "MinProc": tx_freq_min,
+            "MaxProc": tx_freq_max,
+        },
+        "ImageFormAlgo": "RMA",
+        "STBeamComp": "NO",
+        "ImageBeamComp": "SV",
+        "AzAutofocus": "NO",
+        "RgAutofocus": "NO",
+        "Processing": [
+            {
+                "Type": f"sarkit-convert {__version__} @ {now}",
+                "Applied": True,
+            },
+        ],
+    }
+
+    sicd_ew["Antenna"]["TwoWay"]["XAxisPoly"] = ant_x_dir_poly
+    sicd_ew["Antenna"]["TwoWay"]["YAxisPoly"] = ant_y_dir_poly
+    sicd_ew["Antenna"]["TwoWay"]["FreqZero"] = freq_zero
+    sicd_ew["Antenna"]["TwoWay"]["EB"]["DCXPoly"] = eb_dcx_poly
+    sicd_ew["Antenna"]["TwoWay"]["EB"]["DCYPoly"] = eb_dcy_poly
+    sicd_ew["Antenna"]["TwoWay"]["Array"]["GainPoly"] = antenna_array_gain
+    sicd_ew["Antenna"]["TwoWay"]["Array"]["PhasePoly"] = np.zeros(
+        dtype=float, shape=(1, 1)
+    )
+
+    sicd_ew["RMA"] = {
+        "RMAlgoType": "OMEGA_K",
+        "ImageType": "INCA",
+        "INCA": {
+            "TimeCAPoly": time_ca_poly,
+            "R_CA_SCP": scp_rca,
+            "FreqZero": center_frequency,
+            "DRateSFPoly": drsf_poly,
+            "DopCentroidPoly": doppler_centroid_poly,
+        },
+    }
 
-    image_formation.addnext(sksicd.compute_scp_coa(sicd_xml_obj.getroottree()))
+    sicd_ew["SCPCOA"] = sksicd.compute_scp_coa(sicd_xml_obj.getroottree())
 
     # Add Radiometric
     if mission_id == "CSK":
@@ -648,27 +817,16 @@ def hdf5_to_sicd(
             sigmazero_poly = betazero_poly * np.cos(graze) * np.cos(twist)
             gammazero_poly = betazero_poly / np.tan(graze) * np.cos(twist)
 
-            radiometric = sicd.Radiometric(
-                sicd.SigmaZeroSFPoly(), sicd.BetaZeroSFPoly(), sicd.GammaZeroSFPoly()
-            )
-            sksicd.Poly2dType().set_elem(
-                radiometric.find("./{*}SigmaZeroSFPoly"), sigmazero_poly
-            )
-            sksicd.Poly2dType().set_elem(
-                radiometric.find("./{*}BetaZeroSFPoly"), betazero_poly
-            )
-            sksicd.Poly2dType().set_elem(
-                radiometric.find("./{*}GammaZeroSFPoly"), gammazero_poly
-            )
+            sicd_ew["Radiometric"] = {
+                "SigmaZeroSFPoly": sigmazero_poly,
+                "BetaZeroSFPoly": betazero_poly,
+                "GammaZeroSFPoly": gammazero_poly,
+            }
             if rcs_row_sf and rcs_col_sf:
                 rcssf_poly = betazero_poly * (
                     rcs_row_sf * rcs_col_sf / (row_bw * col_bw)
                 )
-                radiometric.find("./{*}SigmaZeroSFPoly").addprevious(sicd.RCSSFPoly())
-                sksicd.Poly2dType().set_elem(
-                    radiometric.find("./{*}RCSSFPoly"), rcssf_poly
-                )
-            sicd_xml_obj.find("./{*}RMA").addprevious(radiometric)
+                sicd_ew["Radiometric"]["RCSSFPoly"] = rcssf_poly
 
     # Add Geodata Corners
     sicd_xmltree = sicd_xml_obj.getroottree()
@@ -685,8 +843,7 @@ def hdf5_to_sicd(
         sarkit.wgs84.up(sarkit.wgs84.cartesian_to_geodetic(scp_ecf)),
     )
     icp_llh = sarkit.wgs84.cartesian_to_geodetic(icp_ecef)
-    xml_helper = sksicd.XmlHelper(sicd_xmltree)
-    xml_helper.set("./{*}GeoData/{*}ImageCorners", icp_llh[:, :2])
+    sicd_ew["GeoData"]["ImageCorners"] = icp_llh[:, :2]
 
     # Validate XML
     sicd_con = sarkit.verification.SicdConsistency(sicd_xmltree)
@@ -708,7 +865,7 @@ def hdf5_to_sicd(
     metadata = sksicd.NitfMetadata(
         xmltree=sicd_xmltree,
         file_header_part={
-            "ostaid": ostaid,
+            "ostaid": h5_attrs["Processing Centre"],
             "ftitle": core_name,
             "security": {
                 "clas": classification[0].upper(),
@@ -756,11 +913,6 @@ def main(args=None):
         type=pathlib.Path,
         help='path of the output SICD file. The string "{pol}" will be replaced with polarization for multiple images',
     )
-    parser.add_argument(
-        "--ostaid",
-        help="content of the originating station ID (OSTAID) field of the NITF header",
-        default="Unknown",
-    )
     config = parser.parse_args(args)
 
     tx_polarizations = []
@@ -810,7 +962,6 @@ def main(args=None):
             h5_filename=config.input_h5_file,
             sicd_filename=img_info["filename"],
             classification=config.classification,
-            ostaid=config.ostaid,
             img_str=img_str,
             chan_index=img_info["chan_index"],
             tx_polarizations=tx_polarizations,