Here is my c++ definition of the metadata I use for stripmap sar.
I think that the SICD format also includes most of these, one way or another.
-Leland Pierce, Aug 2, 2017

================= ANY SENSOR ==============================

std::string raw_header; // the original header data.

std::string platform_name;
std::string sensor_name;
std::string sensor_type;
std::string image_id;
std::string processing_facility;
std::string product_type;
boost::posix_time::ptime acquisition_datetime; // “Mon DD HH:MM:SS.xx UTC YYYY”
boost::posix_time::ptime processing_datetime;
std::string processing_software_version;

// The orbit
// index into the 2d arrays: first index is point along orbit,
// second is x,y,or z component (0,1,2)
std::string orbit_coordinate_system;
std::vector orbit_time_sec;
std::vector orbit_positions_xyz_m;
std::vector orbit_velocities_xyz_m_per_sec;
std::vector orbit_orientations_roll_pitch_yaw_degrees;
std::string descending_or_ascending; // (D or A or I (for irrelevant))
// geo_base::Vec3D is just a vector of 3 doubles

// image georeferencing:
std::vector tie_points_image;
// geo_base::ImageCoordinates is just a vector of 2 doubles

std::vector tie_points_geographic;
// geo_base::GeographicCoordinates is a vector of 2 doubles, plus
// 2 strings: 1 for datum, 1 for projection

// calibration:
double calibration_constant;
bool calibration_constant_applied;
double calibration_noise;

================= SAR STRIPMAP SENSORS (level 1) ================

std::string mode;
std::string polarizations; //constructed like: “[ “HH”, “HV”, ….]”
std::string center_freq_name;
double center_freq_hz;
double pulse_repitition_frequency_hz;
double pulse_repitition_frequency_perpixel_hz;
double pulse_bandwidth_hz;
double pulse_length_sec;
std::string antenna_pointing; // (right or left)
double adc_sampling_rate_hz;
double slant_range_resolution_m;
double azimuth_resolution_m;
std::string sensor_detector; // (square-law or linear? or other?)

// 2-way antenna pattern:
std::vector antenna_elevation_pattern_db;
std::vector antenna_elevation_pattern_look_angle_deg;

std::string calibration_state;// DN propto amplitude, DN propto power,
// DN is sigma0, DN is beta0, DN is gamma0,
// “DN^2 is sigma0 using ellisoidal ground area”
bool elevation_pattern_correction; // t/f
int range_spreading_loss_correction; // t/f/rref
double range_spreading_ref_range_m; // if range spreading loss is
// corrected at a certain reference range.
// This is the value of that range, meters.
bool pulse_dependent_gain_correction; //(I dont know what this is… t/f ???
// it was in radarsat2…)
int divided_by_sine_theta_inc; // t/f/ref
double reference_inc_angle_deg; // if entire image divided by the same sin(theta)
// this is the value of that angle in degrees

double number_of_range_looks;
double range_look_bandwidth_hz;
double number_of_azimuth_looks;
double azimuth_look_bandwidth_hz;
std::string range_window_type; // eg: Kaiser, cos2, …
std::vector range_window_parameters;
std::string azimuth_window_type; // eg Kaiser, cos2, …
std::vector azimuth_window_parameters;
double look_angle_near_range_deg;
double look_angle_far_range_deg;
double near_slant_range_m;
double platform_radius_scene_center_m; // (from earth’s center)
double platform_altitude_m; // (from ellipsoid surface)
double terrain_height_m; // assumed height of ground wrt ellipsoid surface

// first index is polarization, second is polynomial coeff#:
double doppler_centroid_a0_polynomial[4][5]; // hz
double doppler_centroid_a1_polynomial[4][5]; // hz/rngbin
double doppler_centroid_a2_polynomial[4][5]; // hz/rngbin^2
double doppler_centroid_a3_polynomial[4][5]; // hz/rngbin^3, ….
double doppler_centroid_a4_polynomial[4][5];
// uses az-bin# as “x”
// a0 = blah[0] + blah[1]*x +blah[2]*x^2 + ….
// a1 = blah[0] + blah[1]*x +blah[2]*x^2 + ….
// etc.
// doppler_centroid_hz = a0 + a1*rng + a2*rng^2 + ….
double doppler_rate_a0_polynomial[4][5]; //just like doppler centroid. Hz/sec
double doppler_rate_a1_polynomial[4][5];
double doppler_rate_a2_polynomial[4][5];
double doppler_rate_a3_polynomial[4][5];
double doppler_rate_a4_polynomial[4][5];
double doppler_centroid_rangebin_offset;
double doppler_centroid_azimuthbin_offset;
double doppler_rate_rangebin_offset;
double doppler_rate_azimuthbin_offset;

std::string doppler_processing_state; //(“doppler centroid” or “zero doppler”)
double azimuth_spacing_m;
double range_spacing_m;
std::string range_direction; //(+x -x +y -y N/A)
std::string azimuth_direction; // (+x -x +y -y N/A)
std::string geometry; // (slant range, ground range,
//projected to ellipsoid at a certain height,
//orthorectified, ……)
double time_early_azimuth_sec;
double time_late_azimuth_sec;

// raw data
std::string raw_data_overall_datatype;
// valids: “airsar”,
// “airsar compressed stokes matrix”,
// “complex scattering matrix”,
// “complex scattering matrix cross-products”,
// “complex scattering matrix elements”,
// “complex scattering matrix element”,
// “sirc compressed”,
// “sirc compressed scattering matrix”,
// “sirc compressed scattering matrix element”,
// “sirc compressed scattering matrix elements”,
// “sirc compressed amplitude-squared scattering matrix element”,
// “sirc compressed stokes matrix”,
// “sirc compressed stokes matrix elements”,
// “amplitude of scattering matrix”,
// “amplitude of scattering matrix elements”,
// “amplitude of scattering matrix element”,
// “symmetric stokes matrix”,
// “symmetric cross-products”,
// “scattering matrix”,
// “scattering matrix elements”,
// “scattering matrix element”,
// “amplitude-squared scattering matrix element”,
std::vector raw_data_band_names;
int raw_number_of_pixels;
int raw_number_of_lines;