check_input.h

Go to the documentation of this file.

/* Copyright (C) 2002-2012
   Patrick Eriksson <Patrick.Eriksson@chalmers.se>
   Stefan Buehler   <sbuehler@ltu.se>

   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. */

/*===========================================================================
  ===  File description 
  ===========================================================================*/

#ifndef checkinput_h
#define checkinput_h

/*===========================================================================
  === External declarations
  ===========================================================================*/

#include "agenda_class.h"
#include "exceptions.h"
#include "gridded_fields.h"
#include "matpackVII.h"
#include "mystring.h"
//#include <cfloat>

/*===========================================================================
  === Functions in check_input.cc
  ===========================================================================*/

void chk_if_bool(const String& x_name, const Index& x);

void chk_if_in_range(const String& x_name,
                     const Index& x,
                     const Index& x_low,
                     const Index& x_high);

void chk_if_increasing(const String& x_name, const ArrayOfIndex& x);

void chk_not_negative(const String& x_name, const Numeric& x);

void chk_if_in_range(const String& x_name,
                     const Numeric& x,
                     const Numeric& x_low,
                     const Numeric& x_high);

void chk_if_in_range_exclude_low(const String& x_name,
                                 const Numeric& x,
                                 const Numeric& x_low,
                                 const Numeric& x_high);

void chk_if_in_range_exclude_high(const String& x_name,
                                  const Numeric& x,
                                  const Numeric& x_low,
                                  const Numeric& x_high);

void chk_if_in_range_exclude(const String& x_name,
                             const Numeric& x,
                             const Numeric& x_low,
                             const Numeric& x_high);

void chk_vector_length(const String& x_name, ConstVectorView x, const Index& l);

void chk_vector_length(const String& x1_name,
                       const String& x2_name,
                       ConstVectorView x1,
                       ConstVectorView x2);

void chk_if_increasing(const String& x_name, ConstVectorView x);

void chk_if_decreasing(const String& x_name, ConstVectorView x);

void chk_if_equal(const String& x1_name,
                  const String& x2_name,
                  ConstVectorView v1,
                  ConstVectorView v2,
                  Numeric margin = 1e-6);

void chk_matrix_ncols(const String& x_name, ConstMatrixView x, const Index& l);

void chk_matrix_nrows(const String& x_name, ConstMatrixView x, const Index& l);

class runtime_error_not_found : public runtime_error {
 public:
  runtime_error_not_found(const string& s) : runtime_error(s) {}
};

class runtime_error_not_unique : public runtime_error {
 public:
  runtime_error_not_unique(const string& s) : runtime_error(s) {}
};

/*===========================================================================
  === Template Functions for Arrays
  ===========================================================================*/


template <class T>
Index chk_contains(const String& x_name, const Array<T>& x, const T& what) {
  // To generate error messages:
  ostringstream os;

  // To store the positions:
  ArrayOfIndex pos;

  // Find all positions of what in x and store in pos:
  find_all(pos, x, what);

  switch (pos.nelem()) {
    case 0:
      // Not found.
      os << "The array *" << x_name << "* must contain the element " << what
         << ",\n"
         << "but it does not.";
      throw runtime_error_not_found(os.str());
      break;

    case 1:
      // Found once, this is what we want!
      return pos[0];

    default:
      // Found more than once.
      os << "The array *" << x_name << "* must contain the element " << what
         << "\n"
         << "exactly once, but it does contain it " << pos.nelem() << " times.";
      throw runtime_error_not_unique(os.str());
      break;
  }

  return -1;
}


template <class T>
void chk_size(const String& x_name, const Array<T>& x, const Index& c) {
  if (x.nelem() != c) {
    ostringstream os;
    os << "The array *" << x_name << "*\n"
       << "does not have the right size.\n"
       << "The size should be: " << c << "\n"
       << "but it is:          " << x.nelem();
    throw runtime_error(os.str());
  }
}

/*===========================================================================
  === Functions for Tensors
  ===========================================================================*/

void chk_size(const String& x_name, ConstVectorView x, const Index& c);

void chk_size(const String& x_name,
              ConstMatrixView x,
              const Index& r,
              const Index& c);

void chk_size(const String& x_name,
              ConstTensor3View x,
              const Index& p,
              const Index& r,
              const Index& c);

void chk_size(const String& x_name,
              ConstTensor4View x,
              const Index& b,
              const Index& p,
              const Index& r,
              const Index& c);

void chk_size(const String& x_name,
              ConstTensor5View x,
              const Index& s,
              const Index& b,
              const Index& p,
              const Index& r,
              const Index& c);

void chk_size(const String& x_name,
              ConstTensor6View x,
              const Index& v,
              const Index& s,
              const Index& b,
              const Index& p,
              const Index& r,
              const Index& c);

void chk_size(const String& x_name,
              ConstTensor7View x,
              const Index& l,
              const Index& v,
              const Index& s,
              const Index& b,
              const Index& p,
              const Index& r,
              const Index& c);

void chk_not_empty(const String& x_name, const Agenda& x);

void chk_interpolation_grids_loose(Index& ing_min,
                                   Index& ing_max,
                                   const String& which_interpolation,
                                   ConstVectorView old_grid,
                                   ConstVectorView new_grid,
                                   ConstVectorView data,
                                   const Index order = 1);

void chk_interpolation_grids_loose_no_data_check(
    Index& ing_min,
    Index& ing_max,
    const String& which_interpolation,
    ConstVectorView old_grid,
    ConstVectorView new_grid,
    const Index order = 1);

void chk_interpolation_pgrids_loose_no_data_check(
    Index& ing_min,
    Index& ing_max,
    const String& which_interpolation,
    ConstVectorView old_pgrid,
    ConstVectorView new_pgrid,
    const Index order = 1);

void chk_interpolation_grids_loose_check_data(Index& ing_min,
                                              Index& ing_max,
                                              const String& which_interpolation,
                                              ConstVectorView old_grid,
                                              ConstVectorView new_grid,
                                              ConstVectorView data);

void chk_interpolation_grids(const String& which_interpolation,
                             ConstVectorView old_grid,
                             ConstVectorView new_grid,
                             const Index order = 1,
                             const Numeric& extpolfac = 0.5,
                             const bool islog = false);

void chk_interpolation_grids(const String& which_interpolation,
                             ConstVectorView old_grid,
                             const Numeric& new_grid,
                             const Index order = 1,
                             const Numeric& extpolfac = 0.5);

void chk_interpolation_pgrids(const String& which_interpolation,
                              ConstVectorView old_pgrid,
                              ConstVectorView new_pgrid,
                              const Index order = 1,
                              const Numeric& extpolfac = 0.5);

void chk_atm_grids(const Index& dim,
                   ConstVectorView p_grid,
                   ConstVectorView lat_grid,
                   ConstVectorView lon_grid);

void chk_atm_field(const String& x_name,
                   ConstTensor3View x,
                   const Index& dim,
                   ConstVectorView p_grid,
                   ConstVectorView lat_grid,
                   ConstVectorView lon_grid,
                   const bool& chk_lat90 = 1);

void chk_atm_field(const String& x_name,
                   ConstTensor4View x,
                   const Index& dim,
                   const Index& nspecies,
                   ConstVectorView p_grid,
                   ConstVectorView lat_grid,
                   ConstVectorView lon_grid,
                   const bool& check_nan = 1);

void chk_atm_vecfield_lat90(const String& x1_name,
                            ConstTensor3View x1,
                            const String& x2_name,
                            ConstTensor3View x2,
                            const Index& dim,
                            ConstVectorView lat_grid,
                            const Numeric& threshold = 1e-3);
//        const Numeric&    threshold = 2*DBL_EPSILON );

void chk_latlon_true(const Index& atmosphere_dim,
                     ConstVectorView lat_grid,
                     ConstVectorView lat_true,
                     ConstVectorView lon_true);

void chk_atm_surface(const String& x_name,
                     const Matrix& x,
                     const Index& dim,
                     ConstVectorView lat_grid,
                     ConstVectorView lon_grid);

void chk_rte_pos(const Index& atmosphere_dim,
                 ConstVectorView rte_pos,
                 const bool& is_rte_pos2 = false);

void chk_rte_los(const Index& atmosphere_dim, ConstVectorView rte_los);

void chk_griddedfield_gridname(const GriddedField& gf,
                               const Index gridindex,
                               const String& gridname);

void chk_met_mm_backend(const Matrix& bdsp);

#endif  // checkinput_h