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

sarkit_convert/{tsx.py → terrasar.py}

@@ -15,10 +15,11 @@ metadata that would predict the complex data characteristics
 """
 
 import argparse
+import datetime
 import pathlib
 
 import dateutil.parser
-import lxml.builder
+import lxml.etree
 import numpy as np
 import numpy.linalg as npl
 import numpy.polynomial.polynomial as npp
@@ -26,8 +27,8 @@ import sarkit.sicd as sksicd
 import sarkit.verification
 import sarkit.wgs84
 import scipy.constants
-from lxml import etree
 
+from sarkit_convert import __version__
 from sarkit_convert import _utils as utils
 
 NSMAP = {
@@ -57,10 +58,6 @@ def _parse_to_naive(timestamp_str):
     return dateutil.parser.parse(timestamp_str).replace(tzinfo=None)
 
 
-def _naive_to_sicd_str(timestamp):
-    return timestamp.replace(tzinfo=None).isoformat() + "Z"
-
-
 def _boolstr_to_bool(text):
     return text in ("1", "true")
 
@@ -154,7 +151,6 @@ def cosar_to_sicd(
     cosar_file,
     sicd_file,
     classification,
-    ostaid,
     chan_index,
     tx_polarizations,
     tx_rcv_pols,
@@ -196,7 +192,7 @@ def cosar_to_sicd(
     application = generation_system.text
     version = generation_system.attrib["version"]
     creation_application = f"{application} version {version}"
-    creation_site = tsx_xml.findtext(
+    originator_facility = tsx_xml.findtext(
         "./productInfo/generationInfo/level1ProcessingFacility"
     )
 
@@ -491,43 +487,156 @@ def cosar_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"]}
+    # Antenna
+    attitude_elem = tsx_xml.find("./platform/attitude")
+    attitude_utcs = []
+    attitude_quaternions = []
+    for attitude_data in attitude_elem.findall("./attitudeData"):
+        attitude_utcs.append(_parse_to_naive(attitude_data.findtext("./timeUTC")))
+        quat = [
+            float(attitude_data.findtext("./q0")),
+            float(attitude_data.findtext("./q1")),
+            float(attitude_data.findtext("./q2")),
+            float(attitude_data.findtext("./q3")),
+        ]
+        attitude_quaternions.append(quat)
+    attitude_quaternions = np.array(attitude_quaternions)
+
+    def get_mech_frame_from_quat(att_quat):
+        scipy_quat = np.roll(att_quat, -1)
+        return scipy.spatial.transform.Rotation.from_quat(scipy_quat).inv().as_matrix()
+
+    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),
+        )
     )
-    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),
+    good_times = rel_att_times[good_indices]
+    good_att_quat = attitude_quaternions[good_indices]
+    mech_frame = np.array(
+        [get_mech_frame_from_quat(att_quat) for att_quat in good_att_quat]
     )
-    image_creation = sicd.ImageCreation(
-        sicd.Application(creation_application),
-        sicd.DateTime(_naive_to_sicd_str(creation_time)),
-        sicd.Site(creation_site),
+
+    ux_rot = mech_frame[:, 0, :]
+    uy_rot = mech_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 = center_frequency
+    antenna_pattern_elem = tsx_xml.xpath(
+        f'./calibration/calibrationData/antennaPattern[polLayer[text()="{pol_layer}"]]'
+    )[0]
+    antenna_beam_elevation = np.arctan2(
+        float(antenna_pattern_elem.findtext("./beamPointingVector/y")),
+        float(antenna_pattern_elem.findtext("./beamPointingVector/z")),
+    )
+    spotlight_elem = tsx_xml.find(
+        "./productInfo/acquisitionInfo/imagingModeSpecificInfo/spotLight"
+    )
+    if spotlight_elem is not None:
+        azimuth_steering = np.array(
+            [
+                float(spotlight_elem.findtext("./azimuthSteeringAngleFirst")),
+                float(spotlight_elem.findtext("./azimuthSteeringAngleLast")),
+            ]
+        )
+        eb_dcx_poly = npp.polyfit(
+            [0, collection_duration], np.sin(np.deg2rad(azimuth_steering)), 1
+        )
+    else:
+        eb_dcx_poly = [0.0]
+    eb_dcy_poly = [-look * np.sin(antenna_beam_elevation)]
+
+    def get_angles_gains(pattern_elem):
+        antenna_angles = []
+        antenna_gains = []
+        for gain_ext in pattern_elem.findall("./gainExt"):
+            antenna_angles.append(float(gain_ext.attrib["angle"]))
+            antenna_gains.append(float(gain_ext.text))
+        return np.array(antenna_angles), np.array(antenna_gains)
+
+    antenna_rg_angles, antenna_rg_gains = get_angles_gains(
+        antenna_pattern_elem.find("./elevationPattern")
     )
-    image_data = sicd.ImageData(
-        sicd.PixelType(COSAR_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]))),
+    antenna_az_angles, antenna_az_gains = get_angles_gains(
+        antenna_pattern_elem.find("./azimuthPattern")
     )
 
-    def make_xyz(arr):
-        return [sicd.X(str(arr[0])), sicd.Y(str(arr[1])), sicd.Z(str(arr[2]))]
+    fit_order = 4
 
-    def make_llh(arr):
-        return [sicd.Lat(str(arr[0])), sicd.Lon(str(arr[1])), sicd.HAE(str(arr[2]))]
+    def fit_gains(angles, gains):
+        fit_limit = -9
+        array_mask = gains > fit_limit
+        dcs = np.sin(np.deg2rad(angles))
+        return npp.polyfit(dcs[array_mask], gains[array_mask], fit_order)
 
-    # Will add ImageCorners later
-    geo_data = sicd.GeoData(
-        sicd.EarthModel("WGS_84"),
-        sicd.SCP(sicd.ECF(*make_xyz(scp_ecf)), sicd.LLH(*make_llh(scp_llh))),
+    antenna_array_gain = np.zeros((fit_order + 1, fit_order + 1), dtype=float)
+    antenna_array_gain[0, :] = fit_gains(
+        antenna_rg_angles + look * np.rad2deg(antenna_beam_elevation),
+        antenna_rg_gains,
     )
+    antenna_array_gain[:, 0] = fit_gains(antenna_az_angles, 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": COSAR_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 = (
@@ -552,168 +661,180 @@ def cosar_to_sicd(
     col_window_name = proc_param.findtext("./azimuthWindowID")
     col_window_coeff = float(proc_param.findtext("./azimuthWindowCoefficient"))
 
-    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(_naive_to_sicd_str(collection_start_time)),
-        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(st_beam_comp),
-        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,
-    )
-
-    image_formation.addnext(sksicd.compute_scp_coa(sicd_xml_obj.getroottree()))
+        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": st_beam_comp,
+        "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,
+        },
+    }
+
+    sicd_ew["SCPCOA"] = sksicd.compute_scp_coa(sicd_xml_obj.getroottree())
 
     # Add Radiometric
     cal_constant = float(cal_const_elem.findtext("./calFactor"))
@@ -738,28 +859,19 @@ def cosar_to_sicd(
         1e-2,
     )
 
-    radiometric = sicd.Radiometric(
-        sicd.NoiseLevel(sicd.NoiseLevelType("ABSOLUTE"), sicd.NoisePoly()),
-        sicd.SigmaZeroSFPoly(),
-        sicd.BetaZeroSFPoly(),
-        sicd.GammaZeroSFPoly(),
-    )
-    sksicd.Poly2dType().set_elem(
-        radiometric.find("./{*}NoiseLevel/{*}NoisePoly"), noise_poly
-    )
-    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"] = {
+        "NoiseLevel": {
+            "NoiseLevelType": "ABSOLUTE",
+            "NoisePoly": noise_poly,
+        },
+        "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()
@@ -776,18 +888,15 @@ def cosar_to_sicd(
         sarkit.wgs84.up(sarkit.wgs84.cartesian_to_geodetic(scp_ecf)),
     )
     icp_llh = sarkit.wgs84.cartesian_to_geodetic(icp_ecef)
-    image_corners = sicd.ImageCorners()
-    sksicd.ImageCornersType().set_elem(image_corners, icp_llh[:, :2])
-    geo_data.append(image_corners)
+    sicd_ew["GeoData"]["ImageCorners"] = icp_llh[:, :2]
 
     # Add RNIIRS
-    xml_helper = sksicd.XmlHelper(sicd_xmltree)
-    inf_density, pred_rniirs = utils.get_rniirs_estimate(xml_helper)
-    collection_info.append(
-        sicd.Parameter({"name": "INFORMATION_DENSITY"}, f"{inf_density:.2g}")
+    inf_density, pred_rniirs = utils.get_rniirs_estimate(sicd_ew)
+    sicd_ew["CollectionInfo"].add(
+        "Parameter", ("INFORMATION_DENSITY", f"{inf_density:.2g}")
     )
-    collection_info.append(
-        sicd.Parameter({"name": "PREDICTED_RNIIRS"}, f"{pred_rniirs:.2g}")
+    sicd_ew["CollectionInfo"].add(
+        "Parameter", ("PREDICTED_RNIIRS", f"{pred_rniirs:.1f}")
     )
 
     # Validate XML
@@ -803,7 +912,7 @@ def cosar_to_sicd(
     metadata = sksicd.NitfMetadata(
         xmltree=sicd_xmltree,
         file_header_part={
-            "ostaid": ostaid,
+            "ostaid": originator_facility,
             "ftitle": core_name,
             "security": {
                 "clas": classification[0].upper(),
@@ -847,17 +956,12 @@ 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)
 
     if not config.input_xml_file.is_file():
         raise ValueError(f"Input XML file {str(config.input_xml_file)} is not a file")
 
-    tsx_xml = etree.parse(config.input_xml_file).getroot()
+    tsx_xml = lxml.etree.parse(config.input_xml_file).getroot()
 
     images = dict()
     img_ndx = 1
@@ -895,7 +999,6 @@ def main(args=None):
             cosar_file=img_info["cosar_filename"],
             sicd_file=img_info["sicd_filename"],
             classification=config.classification,
-            ostaid=config.ostaid,
             chan_index=img_info["chan_index"],
             tx_polarizations=tx_polarizations,
             tx_rcv_pols=tx_rcv_pols,