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 "matpackVII.h"
#include "mystring.h"
#include "gridded_fields.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_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 );
 
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);
 
bool chk_if_std_blackbody_agenda( 
         Workspace&   ws,
   const Agenda&      blackbody_radiation_agenda );
 
#endif  // checkinput_h