l_rad_driver.h

Go to the documentation of this file.

#ifndef L_RAD_DRIVER_H
#define L_RAD_DRIVER_H

#include <boost/noncopyable.hpp>
#include <blitz/array.h>

#include "linear_interpolate.h"
#include "array_ad.h"

namespace FullPhysics {
/****************************************************************/
class LRadDriver : public Printable<LRadDriver>, public boost::noncopyable {

public:
    enum PsMode {REGULAR, ENHANCED, PLANE_PARALLEL, DETECT};

    LRadDriver(int Number_stream, int Number_stokes,
               int surface_type,
               bool Tms_Correction = false,
               bool Pure_nadir = false,
               const PsMode ps_mode = DETECT);

    virtual ~LRadDriver();

    virtual int number_stokes() const {return nstokes;}
    virtual int number_stream() const {return nstream;}

    ArrayAd<double, 2> z_matrix(const ArrayAd<double, 3>& pf) const;

    virtual void setup_geometry(blitz::Array<double, 1> alt, double sza, double zen, double azm) const;

    virtual void setup_surface_params(const blitz::Array<double, 1>& surface_param);

    virtual void setup_optical_inputs(const blitz::Array<double, 1>& od, 
                                      const blitz::Array<double, 1>& ssa,
                                      const blitz::Array<double, 3>& pf,
                                      const blitz::Array<double, 2>& zmat);

    virtual void clear_linear_inputs();

    virtual void setup_linear_inputs(const ArrayAd<double, 1>& od,
                                     const ArrayAd<double, 1>& ssa,
                                     const ArrayAd<double, 3>& pf,
                                     const ArrayAd<double, 2>& zmat);

    virtual void calculate_first_order();

    virtual void calculate_second_order();

    virtual blitz::Array<double, 1> stokes() const;

    virtual blitz::Array<double, 3> atmospheric_jacobian() const;
    
    virtual blitz::Array<double, 2> surface_jacobian() const;

    virtual void print(std::ostream& Os, bool Short_form = false) const;

private:

    void set_ps_mode(const PsMode& mode)
    {
        switch(mode) {
        case REGULAR:
            regular_ps = true;
            enhanced_ps = false;
            break;

        case ENHANCED:
            regular_ps = false;
            enhanced_ps = true;
            break;

        case PLANE_PARALLEL:
            regular_ps = false;
            enhanced_ps = false;
            break;

        case DETECT:
        default:

            // Determine which pseudo-spherical mode to use based on the zenith angle
            // ie, how close are we to nadir
            if (pure_nadir) {
                set_ps_mode(REGULAR);
            } else {
                set_ps_mode(ENHANCED);
            }

            break;
        }
    }

    void initialize(const PsMode ps_mode);
    void check_rt_inputs();

    // Options configured at construction
    int nstream, nstokes;
    int surface_type;
    bool use_tms_correction;
    bool pure_nadir;
    bool regular_ps, enhanced_ps;

    // Integer boolean for l_rad indicating if jacobians are needed, false until linear
    // values are initialized
    int need_jacobians_i;

    // Fortran ordered Blitz arrays used when calling l_rad. They are initialized on first use
    blitz::Array<double, 1> surface_param_f; 
    blitz::Array<double, 1> tau_f; 
    blitz::Array<double, 1> omega_f; 
    blitz::Array<double, 3> pf_f; 
    blitz::Array<double, 2> zmat_f; 
    blitz::Array<double, 1> fscale_f; 
    blitz::Array<double, 3> jac_atm_f; 
    blitz::Array<double, 2> jac_surf_f; 
    blitz::Array<double, 2> l_tau_f; 
    blitz::Array<double, 2> l_omega_f; 
    blitz::Array<double, 4> l_pf_f; 
    blitz::Array<double, 3> l_zmat_f; 
    blitz::Array<double, 2> l_fscale_f; 
    blitz::Array<double, 1> stokes_val_f; 

    mutable void *l_rad_struct;

};
}
#endif