DbAlgorithm.h

Go to the documentation of this file.

/*
 * DbAlgorithm.h
 *
 *  Created on: May 2, 2018
 *      Author: Sam Anderson
 */
 
#ifndef INCLUDE_DBALGORITHM_H_
#define INCLUDE_DBALGORITHM_H_
 
#include <DDAlgorithm.h>
#include <DDProcess.h>
#include <DDOptions.h>
#include "deepblue/DbLutNetcdf.h"
#include "deepblue/DbMask.h"
 
using namespace std;
 
enum OBANDS_ENUM {
    O488,           // m03
    O550,           // m04
    O670,           // m05
    O865,           // m07
    O1240,          // m08
    O1610,          // m10
    O2250,          // m11
    OMAXBAND
};
 
enum NCBANDS_ENUM {
    NC412,           // m01
    NC488,           // m03
    NC670,           // m05
    NCMAXBAND
};
 
enum LBANDS_ENUM {
    OL412,           // m01
    OL488,           // m03
    OL670,           // m05
    LMAXBAND
};
 
enum OMODEL_ENUM {
    DUST,
    FINE,
    MARI,
    MIX,
    BEST,
    NMODEL
};
 
 
class DbCloudMaskOcean;
class DbCloudMaskLand;
class DbSmokeMask;
class DbHighAltSmokeMask;
class DbPyrocbMask;
 
class DbAlgorithm : public DDAlgorithm
{
    friend class DbCloudMaskLand;
    friend class DbCloudMaskOcean;
    friend class DbSmokeMask;
    friend class DbHighAltSmokeMask;
    friend class DbPyrocbMask;
public:
 
// algorithm constants
 
    static constexpr int No_byte = 6;
    static constexpr int Fmax = 150;
    static constexpr int Lmax = 210;
    static constexpr int Fbmax = 1500;
    static constexpr int Lbmax = 2100;
    static constexpr int No_byte_O = 5;
    static constexpr float delta = -0.000001;
    static constexpr float SolarZenithAngleZEPS = 84.000001;
    static constexpr float NDVI1_CUTOFF = 0.18;
    static constexpr float NDVI2_CUTOFF = 0.35;
    static const float xzlog[10];
    static const float xlog[8];
    static const float htab[8];
    static const float ttab[8];
    static const float ptab[8];
    static const float gtab[8];
 
    DbAlgorithm();
 
    virtual ~DbAlgorithm ();
 
    virtual int initialize( map<string, ddata*> imap );
 
    virtual vector<string>  get_products() { return {};};
 
    virtual map<string, ddata*> process(vector<size_t> start, vector<size_t> count,
            map<string, ddata*> imap);
 
 
    int compute_gas_correction();
 
    int   ler_start_[2];
    int   ler_edge_[2];
    int   dateline_;
    float cphi_;
    float cphir_;
    float phs_;
    float phsr_;
 
    float NC_[DB_NC_BANDS];
 
    float   scatter_angle_;
    float   glint_angle_;
    float   glint_refl_;
    float   ndvi_;
 
    dbTablesLUT*            mt_lut_;
    dbSurfacePressureLUT*   sp_lut_;
    dbSurfCoeffLimited*     scl_lut_;
    dbGeozoneLUT*           gz_lut_;
    dbViirsSurfReflLimited* vsr_lut_;
    dbModisSurfReflLimited* msr_lut_;
    dbOceanAerosolLUMA*     oaLut_[NDBMDL];
    dbBathymetryLUT*        bath_lut_;
    dbChlLUT*               chl_lut_;
 
//    dbLUT*                  db_lut_;
//    dbNvalxLUT*             nv_lut_;
//    dbViirsSwirVsVisLUT*    vsv_lut_;
//    dbRayleighLUT*          ra_lut_;
//    dbLandcoverLUT*         lc_lut_;
//    dbModisCorrectionsLUT*  mc_lut_;
//    dbModisSwirVsVisLUT*    msv_lut_;
 
 
protected:
 
    int initialize_LUT_data( map<string, ddata*> imap );
 
    int locate(int size, float y[], float x, int& status);
 
    int compute_pressure (float height, float& sigma, float& ps, float& theta);
 
    int compute_glint_angle(float& glint_angle);
 
    int compute_scatter_angle(float& scat_angle);
 
};
 
 
class DbAlgOcean : public DbAlgorithm
{
public:
 
    DbAlgOcean();
 
    ~DbAlgOcean ();
 
    int initialize( map<string, ddata*> imap );
 
    vector<string>  get_products() { return {"cloud_mask", "quality_flag", "aerosol_type",
        "l2_flags", "scattering_angle", "chlorophyll", "fmf_550", "angstrom", "aot_380",
        "aot_490", "aot_550", "aot_670","aot_865", "aot_1240", "aot_1610", "aot_2250"};};
 
    map<string, ddata*> process(vector<size_t> start, vector<size_t> count,
            map<string, ddata*> imap);
 
    struct osOut {
        float aot550;
        float chl;
        float fmf;
        float ae;
        float ss;
        float aot[NOWL];
        short alg_flag;
        short model_flag;
    };
 
    osOut oOut_[NDBMDL+1];
 
    float chl_;
    float bathy_;
    short mask_cm_;
    short mask_cm_osi_;
 
    DbCloudMaskOcean* cm_;
 
protected:
 
    int initialize_LUT_data();
 
    float calc_glint_refl(size_t iy, size_t ix, int& status);
 
    int run_inversion(size_t iy, size_t ix, dbOceanAerosolLUMA* lut, osOut* iout);
 
    int linfit(int size, float x[], float y[], float r[]);
 
    float calc_turbid_residual(float sza, float r488,
            float r1240, float r1600, float r2250, float r550, int& status );
 
    int set_fill_out();
};
 
 
class DbAlgLand : public DbAlgorithm
{
public:
 
    DbAlgLand();
 
    ~DbAlgLand ();
 
    int initialize( map<string, ddata*> imap );
 
    vector<string>  get_products() { return {"cloud_mask", "quality_flag", "aerosol_type",
        "l2_flags", "scattering_angle", "fmf_550", "angstrom", "aot_380",
        "aot_410", "aot_550", "aot_490", "aot_670"};};
 
    map<string, ddata*> process(vector<size_t> start, vector<size_t> count,
            map<string, ddata*> imap);
 
    int algflg_;
    float cofs_[16];
 
    float   sca_;
    float   gla_;
    float   amf_;
    float   ler412_;
    float   ler488_;
    float   ler670_;
    float   qdf412_;
    float   qdf488_;
    float   qdf670_;
    float   sr412_;
    float   sr488_;
    float   sr670_;
    float   btd8_;
    float   btd11_;
    float   dstar_;
 
    struct lsOut {
        float aot550;
        float ae;
        float ndvi;
        float aot[NLWL];
        float ssa[NLWL];
        float sr[NLWL];
        short sfc_type;
        short alg_flag;
        short aerosol_type;
    };
 
    lsOut lOut_;
 
    DbCloudMaskLand*        cm_;
    DbSmokeMask*            smoke_;
    DbHighAltSmokeMask*     ha_smoke_;
    DbPyrocbMask*           pyrocb_;
 
    short mask_cm_;
    short mask_smoke_;
    short mask_ha_smoke_;
    short mask_pyrocb_;
 
protected:
 
    float densol_[7][4];
    float denscn_[5][4];
    int   isnow_ = 0;
    float pcloud_ = 0.7;
    float pteran_ = 0;
 
    int initialize_LUT_data();
    int initialize_LUT_data( map<string, ddata*> imap );
 
    int compute_stdv();
 
    int compute_dstar(const size_t iy, const size_t ix);
 
    int compute_sr(const size_t iy, const size_t ix);
 
    int compute_ler(const size_t iy, const size_t ix);
 
    int interx(int i1, int i2, rhot_band w, float& ezero,
                float& tr, float& sb);
 
    int set_fill_out();
 
};
 
#endif /* INCLUDE_DBALGORITHM_H_ */