ElNullRangeEst.h

#pragma once
 
#include <cmath>
#include <complex>
#include <optional>
#include <string>
#include <tuple>
#include <vector>
 
#include <Eigen/Dense>
 
#include <isce3/core/Attitude.h>
#include <isce3/core/DateTime.h>
#include <isce3/core/EMatrix.h>
#include <isce3/core/Ellipsoid.h>
#include <isce3/core/Linspace.h>
#include <isce3/core/Orbit.h>
#include <isce3/core/Poly1d.h>
#include <isce3/geometry/DEMInterpolator.h>
 
#include "Frame.h"
 
namespace isce3 { namespace antenna {

struct NullProduct {
    double slant_range;
    double el_angle;
    double doppler;
    double magnitude;
};

struct NullConvergenceFlags {
    bool newton_solver;
    bool geometry_echo;
    bool geometry_antenna;
};

struct NullPowPatterns {
    Eigen::ArrayXd ant;
    Eigen::ArrayXd echo;
    Eigen::ArrayXd el;
};

class ElNullRangeEst {
    // aliases
public:
    using RowMatrixXcf = isce3::core::EMatrix2D<std::complex<float>>;
 
protected:
    using Linspace_t = isce3::core::Linspace<double>;
    using tuple_null = std::tuple<isce3::core::DateTime, NullProduct,
            NullProduct, NullConvergenceFlags, NullPowPatterns>;
 
public:
    // constructors
    ElNullRangeEst(double wavelength, double sr_spacing, double chirp_rate,
            double chirp_dur, const isce3::core::Orbit& orbit,
            const isce3::core::Attitude& attitude,
            const isce3::geometry::DEMInterpolator& dem_interp = {},
            const Frame& ant_frame = {},
            const isce3::core::Ellipsoid& ellips = {},
            double el_res = 8.726646259971648e-06, double abs_tol_dem = 1.0,
            int max_iter_dem = 20, int polyfit_deg = 6);
 
    // methods
    std::tuple<isce3::core::DateTime, NullProduct, NullProduct,
            NullConvergenceFlags, NullPowPatterns>
    genNullRangeDoppler(const Eigen::Ref<const RowMatrixXcf>& echo_left,
            const Eigen::Ref<const RowMatrixXcf>& echo_right,
            const Eigen::Ref<const Eigen::ArrayXcd>& el_cut_left,
            const Eigen::Ref<const Eigen::ArrayXcd>& el_cut_right,
            double sr_start, double el_ang_start, double el_ang_step,
            double az_ang, std::optional<double> az_time = {}) const;

    double waveLength() const { return _wavelength; }

    double slantRangeSpacing() const { return _sr_spacing; }

    std::string gridTypeName() const { return toStr(_ant_frame.gridType()); }

    Eigen::ArrayXcf chirpSampleRef() const
    {
        return Eigen::Map<const Eigen::ArrayXcf>(
                _chirp_ref.data(), _chirp_ref.size());
    }

    std::string refEpoch() const { return _ref_epoch.isoformat(); }

    double demRefHeight() const { return _dem_interp.refHeight(); }

    double midTimeOrbit() const { return _az_time_mid; }

    double maxElSpacing() const { return _el_res_max; }

    double atolDEM() const { return _abs_tol_dem; }

    int maxIterDEM() const { return _max_iter_dem; }

    double atolNull() const { return _ftol_newton; }

    int maxIterNull() const { return _max_iter_newton; }

    int polyfitDeg() const { return _polyfit_deg; }
 
protected:
    double _wavelength;
    double _sr_spacing;
    isce3::core::Orbit _orbit;
    isce3::core::Attitude _attitude;
    isce3::geometry::DEMInterpolator _dem_interp;
    Frame _ant_frame;
    isce3::core::Ellipsoid _ellips;
    double _el_res_max; // (rad)
    double _abs_tol_dem;
    int _max_iter_dem;
    int _polyfit_deg;
 
    // weighted complex chirp reference
    std::vector<std::complex<float>> _chirp_ref;
    // orbit mid azimuth time and reference epoch
    double _az_time_mid;
    isce3::core::DateTime _ref_epoch;
 
    // func tolerance and max iteration for Newton solver
    const double _ftol_newton {1e-5};
    const int _max_iter_newton {25};
};
 
}} // namespace isce3::antenna