telsem.h

Go to the documentation of this file.

/* Copyright (C) 2017
   Oliver Lemke <olemke@core-dump.info>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA.
*/
 
#ifndef telsem_h
#define telsem_h
 
#include <array>
#include "array.h"
#include "matpackIII.h"
#include "mystring.h"
#include "xml_io.h"
 
class TelsemAtlas {
 public:
  TelsemAtlas() = default;
  TelsemAtlas(const TelsemAtlas &) = default;
  TelsemAtlas(TelsemAtlas &&) = default;
  TelsemAtlas &operator=(const TelsemAtlas &) = default;
  TelsemAtlas &operator=(TelsemAtlas &&) = default;
  ~TelsemAtlas() = default;
 
  TelsemAtlas(String filename);
 
  void set_month(Index m) { month = m; }
  Index get_month() const { return month; }
 
  const Tensor3 &get_correl() const { return correl; }
  void set_correl(const Tensor3 &t) { correl = t; }
 
  bool contains(Index cellnumber) const {
    if (cellnumber >= correspondence.nelem()) {
      return false;
    }
    return correspondence[cellnumber] >= 0;
  }
 
  Index get_class1(Index cellnumber) const {
    Index ind = correspondence[cellnumber];
    if (ind < 0) {
      throw std::runtime_error("The cell is not contained in the atlas.");
    }
    return classes1[ind];
  }
 
  Index get_class2(Index cellnumber) const {
    Index ind = correspondence[cellnumber];
    if (ind < 0) {
      throw std::runtime_error("The cell is not contained in the atlas.");
    }
    return classes2[ind];
  }
 
  Vector get_emis_v(Index i) const {
    Index ind = correspondence[i];
    Vector e_v(3);
    if (ind < 0) {
      throw std::runtime_error("The cell is not contained in the atlas.");
    } else {
      e_v[0] = emis(ind, 0);
      e_v[1] = emis(ind, 3);
      e_v[2] = emis(ind, 5);
    }
    return e_v;
  }
 
  Vector get_emis_h(Index cellnum) const {
    Index ind = correspondence[cellnum];
    Vector e_h(3);
    if (ind < 0) {
      throw std::runtime_error("The cell is not contained in the atlas.");
    } else {
      e_h[0] = emis(ind, 1);
      e_h[1] = emis(ind, 4);
      e_h[2] = emis(ind, 6);
    }
    return e_h;
  }
 
  ConstVectorView operator[](Index cellnumber) const {
    Index ind = correspondence[cellnumber];
    if (ind < 0) {
      throw std::runtime_error("The cell is not contained in the atlas.");
    } else {
      return emis(ind, joker);
    }
  }
 
  void read(std::istream &is);
 
  void equare();
 
  void telsem_calc_correspondence();
 
  Index calc_cellnum(Numeric lat, Numeric lon) const;
 
  Index calc_cellnum_nearest_neighbor(Numeric lat, Numeric lon) const;
 
  std::pair<Numeric, Numeric> get_coordinates(Index cellnum) const;
 
  Numeric interp_freq2(Numeric emiss19,
                       Numeric emiss37,
                       Numeric emiss85,
                       Numeric f,
                       Index class2) const;
 
  std::pair<Numeric, Numeric> emis_interp(Numeric theta,
                                          Numeric freq,
                                          Index class1,
                                          Index class2,
                                          const ConstVectorView &ev,
                                          const ConstVectorView &eh) const;
 
  friend std::ostream &operator<<(std::ostream &os, const TelsemAtlas &ta);
  friend void xml_write_to_stream(ostream &,
                                  const TelsemAtlas &,
                                  bofstream *,
                                  const String &,
                                  const Verbosity &);
 
  friend void xml_read_from_stream(istream &,
                                   TelsemAtlas &,
                                   bifstream *,
                                   const Verbosity &);
 
  // Number of lines in the Atlas.
  Index& DataCount() {return ndat;}
  
  // Number of channels in the Atlas.
  Index& ChannelCount() {return nchan;}
  
  // Name of the atlas (including version number).
  String& Name() {return name;}
  
  // Month of the Atlas.
  Index& Month() {return month;}
  
  // Resolution of the Atlas.
  Numeric& Lat() {return dlat;}
  
  // Number of cells per lat band.
  ArrayOfIndex& Cells() {return ncells;}
  
  // The first cell number of lat band.
  ArrayOfIndex& FirstCells() {return firstcells;}
  
  // Emissivities
  Matrix& Emis() {return emis;}
  
  // Emissivity uncertainties.
  Matrix& Emis_err() {return emis_err;}
  
  // Emissivity correlations.
  Tensor3& Correlations() {return correl;}
  
  // Surface classes.
  ArrayOfIndex& Classes1() {return classes1;}
  ArrayOfIndex& Classes2() {return classes2;}
  
  // Cellnumber of each of the pixels in the atlas.
  ArrayOfIndex& Cellnumber() {return cellnums;}
  
  // Derived from file data
  ArrayOfIndex& Correspondance() {return correspondence;}
  
  // Regression coefficients.
  Numeric A0_K0(Index i) {return a0_k0[i];}
  Numeric A0_K1(Index i) {return a0_k1[i];}
  Numeric A0_K2(Index i) {return a0_k2[i];}
  Numeric A0_EVEH(Index i) {return a0_eveh[i];}
  Numeric A1_EVEH(Index i) {return a1_eveh[i];}
  Numeric A2_EVEH(Index i) {return a2_eveh[i];}
  Numeric A3_EVEH(Index i) {return a3_eveh[i];}
  Numeric B0_EVEH(Index i) {return b0_eveh[i];}
  Numeric B1_EVEH(Index i) {return b1_eveh[i];}
  Numeric B2_EVEH(Index i) {return b2_eveh[i];}
  Numeric B3_EVEH(Index i) {return b3_eveh[i];}
  Numeric RAPPORT43_32(Index i) {return rapport43_32[i];}
  Numeric RAPPORT54_43(Index i) {return rapport54_43[i];}
  
 private:
  // Number of lines in the Atlas.
  Index ndat;
  // Number of channels in the Atlas.
  Index nchan;
  // Name of the atlas (including version number).
  String name;
  // Month of the Atlas.
  Index month;
  // Resolution of the Atlas.
  Numeric dlat;
  // Number of cells per lat band.
  ArrayOfIndex ncells;
  // The first cell number of lat band.
  ArrayOfIndex firstcells;
  // Emissivities
  Matrix emis;
  // Emissivity uncertainties.
  Matrix emis_err;
  // Emissivity correlations.
  Tensor3 correl;
  // Surface classes.
  ArrayOfIndex classes1;
  ArrayOfIndex classes2;
  // Cellnumber of each of the pixels in the atlas.
  ArrayOfIndex cellnums;
  // Derived from file data
  ArrayOfIndex correspondence;
 
  // Regression coefficients.
  static const std::array<Numeric, 30> a0_k0;
  static const std::array<Numeric, 30> a0_k1;
  static const std::array<Numeric, 30> a0_k2;
  static const std::array<Numeric, 30> a0_eveh;
  static const std::array<Numeric, 30> a1_eveh;
  static const std::array<Numeric, 30> a2_eveh;
  static const std::array<Numeric, 30> a3_eveh;
  static const std::array<Numeric, 30> b0_eveh;
  static const std::array<Numeric, 30> b1_eveh;
  static const std::array<Numeric, 30> b2_eveh;
  static const std::array<Numeric, 30> b3_eveh;
  static const std::array<Numeric, 4> rapport43_32;
  static const std::array<Numeric, 4> rapport54_43;
};
 
typedef Array<TelsemAtlas> ArrayOfTelsemAtlas;
 
std::ostream &operator<<(std::ostream &os, const TelsemAtlas &ta);
 
#endif /* telsem_h */