empirical_orthogonal_function.h

Go to the documentation of this file.

#ifndef EMPIRICAL_ORTHOGONAL_FUNCTION_H
#define EMPIRICAL_ORTHOGONAL_FUNCTION_H

#include "dispersion.h"
#include "instrument_correction.h"
#include "hdf_file.h"
#include "sub_state_vector_array.h"
#include "array_with_unit.h"
#include <boost/lexical_cast.hpp>

namespace FullPhysics {
/****************************************************************/
class EmpiricalOrthogonalFunction : 
public SubStateVectorArray<InstrumentCorrection> {
public:
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
  
  EmpiricalOrthogonalFunction(double Coeff, 
                              bool Used_flag,
                              const ArrayWithUnit<double, 1>& Eof_waveform,
                              int Order,
                              const std::string& Band_name,
                              const std::string& Hdf_group = "N/A",
                              int Sounding_number = 0,
                              bool Eof_depend_on_sounding_number = false)
    : SubStateVectorArray<InstrumentCorrection>(Coeff, Used_flag),
      band_name(Band_name),
      hdf_group(Hdf_group),
      order_(Order),
      sounding_number_(Sounding_number),
      eof_depend_on_sounding_number_(Eof_depend_on_sounding_number),
      eof_(Eof_waveform)
  { }

  EmpiricalOrthogonalFunction(double Coeff, 
                              bool Used_flag,
                              const Dispersion& Disp,
                              const HdfFile& Hdf_static_input,
                              int Spec_index,
                              int Sounding_number,
                              int Order,
                              const std::string& Band_name,
                              const std::string& Hdf_group = 
                              "Instrument/EmpiricalOrthogonalFunction");
  EmpiricalOrthogonalFunction(double Coeff, 
                              bool Used_flag,
                              const HdfFile& Hdf_static_input,
                              int Spec_index,
                              int Sounding_number,
                              int Order,
                              const std::string& Band_name,
                              const std::string& Hdf_group = 
                              "Instrument/EmpiricalOrthogonalFunction");
  EmpiricalOrthogonalFunction(double Coeff, 
                              bool Used_flag,
                              const HdfFile& Hdf_static_input,
                              const ArrayWithUnit<double, 1>& Uncertainty,
                              int Spec_index,
                              int Sounding_number,
                              int Order,
                              const std::string& Band_name,
                              const std::string& Hdf_group = 
                              "Instrument/EmpiricalOrthogonalFunction",
                              double Scale_to_stddev = 1e19);
  virtual ~EmpiricalOrthogonalFunction() {}

  virtual std::string sub_state_identifier() const { return "eof/" + band_name; }

  virtual std::string state_vector_name_i(int i) const
  { return "EOF order " + boost::lexical_cast<std::string>(order_) +
      " scale factor " + band_name; }

  virtual boost::shared_ptr<InstrumentCorrection> clone() const;
  virtual void apply_correction
  (const SpectralDomain& Pixel_grid,
   const std::vector<int>& Pixel_list,
   SpectralRange& Radiance) const;
  virtual void print(std::ostream& Os) const;

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
  ArrayWithUnit<double, 1> eof() const
  {
    return ArrayWithUnit<double, 1>
      (blitz::Array<double, 1>(coeff(0).value() * eof_.value), 
       eof_.units);
  }

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  int order() const {return order_;}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  double scale() const { return coeff.value()(0); }

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  double scale_uncertainty() const 
  { 
    if(sv_cov_sub.rows() < 1)
      return 0;
    double t = sv_cov_sub(0,0);
    return (t < 0 ? 0 : sqrt(t)); 
  }

private:
  std::string band_name;
  std::string hdf_group;
  int order_;
  int sounding_number_;
  bool eof_depend_on_sounding_number_;
  bool eof_scale_uncertainty_;
  double scale_to_stddev_;
  ArrayWithUnit<double, 1> eof_;
};
}
#endif