gridded_fields.h

Go to the documentation of this file.

/* Copyright (C) 2002-2008 Claudia Emde <claudia.emde@dlr.de>

   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 gridded_fields_h
#define gridded_fields_h

#include "matpackIV.h"
#include "array.h"
#include "mystring.h"

typedef enum {
  GRIDTYPE_NUMERIC,
  GRIDTYPE_STRING
} GridType;

typedef Array<GridType> ArrayOfGridType;

class GField
{
private:
  Index dim;
  String mname;
  Array<GridType> mgridtypes;
  ArrayOfString mgridnames;
  Array<ArrayOfString> mstringgrids;
  ArrayOfVector mnumericgrids;

protected:

  GField() : dim(0),
             mname(),
             mgridtypes(),
             mgridnames(),
             mstringgrids(),
             mnumericgrids()
  { /* Nothing to do here */ };


  GField(const Index d, const String s) : dim(d),
                                          mname(s),
                                          mgridtypes(d, GRIDTYPE_NUMERIC),
                                          mgridnames(d),
                                          mstringgrids(d),
                                          mnumericgrids(d)
  { /* Nothing to do here */ }
                                          

public:

  Index get_dim () const { return dim; }

  void copy_grids (const GField& gf);


  const String& get_grid_name (Index i) const { return mgridnames[i]; }

  Index get_grid_size (const Index i) const;


  GridType get_grid_type (Index i) const { return mgridtypes[i]; }

  ConstVectorView get_numeric_grid (Index i) const;

  VectorView get_numeric_grid (Index i);

  const ArrayOfString& get_string_grid (Index i) const;

  ArrayOfString& get_string_grid (Index i);


  const String& get_name () const { return mname; }

  void set_grid (Index i, const Vector& g);

  void set_grid (Index i, const ArrayOfString& g);


  void set_gridname (Index i, const String& s)
    {
      assert (i < dim);
      mgridnames[i] = s;
    };


  void set_name (const String& s) { mname = s; }


  virtual bool checksize() const { return false; };

  virtual ~GField() { }

  friend ostream& operator<<(ostream& os, const GField& gf);
};


class GField1: public GField, public Vector
{
public:
  GField1() : GField(1, "") {};

  GField1(const String s) : GField(1, s) {};


  virtual bool checksize() const
    {
      return (nelem() == get_grid_size(0));
    }


  void resize(const GField1& gf)
    {
      Vector::resize(gf.get_grid_size(0));
    }


  void resize(Index n)
    {
      Vector::resize(n);
    }

  friend ostream& operator<<(ostream& os, const GField1& gf);
};


class GField2: public GField, public Matrix
{
public:
  GField2() : GField(2, "") {};

  GField2(const String s) : GField(2, s) {};


  virtual bool checksize() const
    {
      return (ncols() == get_grid_size(1)
              && nrows() == get_grid_size(0));
    }


  void resize(const GField2& gf)
    {
      Matrix::resize(gf.get_grid_size(0),
                     gf.get_grid_size(1));
    }


  void resize(Index r, Index c)
    {
      Matrix::resize(r, c);
    }

  friend ostream& operator<<(ostream& os, const GField2& gf);
};


class GField3: public GField, public Tensor3
{
public:
  GField3() : GField(3, "") {};

  GField3(const String s) : GField(3, s) {};

  GField3& operator=(Numeric n)
    {
      Tensor3::operator=(n);

      return *this;
    }


  virtual bool checksize() const
    {
      return (ncols() == get_grid_size(2)
              && nrows() == get_grid_size(1)
              && npages() == get_grid_size(0));
    }


  void resize(const GField3& gf)
    {
      Tensor3::resize(gf.get_grid_size(0),
                      gf.get_grid_size(1),
                      gf.get_grid_size(2));
    }


  void resize(Index p, Index r, Index c)
    {
      Tensor3::resize(p, r, c);
    }

  friend ostream& operator<<(ostream& os, const GField3& gf);
};


class GField4: public GField, public Tensor4
{
public:
  GField4() : GField(4, "") {};

  GField4(const String s) : GField(4, s) {};


  virtual bool checksize() const
    {
      return (ncols() == get_grid_size(3)
              && nrows() == get_grid_size(2)
              && npages() == get_grid_size(1)
              && nbooks() == get_grid_size(0));
    }


  void resize(const GField4& gf)
    {
      Tensor4::resize(gf.get_grid_size(0),
                      gf.get_grid_size(1),
                      gf.get_grid_size(2),
                      gf.get_grid_size(3));
    }


  void resize(Index b, Index p, Index r, Index c)
    {
      Tensor4::resize(b, p, r, c);
    }

  friend ostream& operator<<(ostream& os, const GField4& gf);
};


/********** Output operators **********/

ostream& operator<<(ostream& os, const GField& gf);
ostream& operator<<(ostream& os, const GField1& gf);
ostream& operator<<(ostream& os, const GField2& gf);
ostream& operator<<(ostream& os, const GField3& gf);
ostream& operator<<(ostream& os, const GField4& gf);

/**************************************/


typedef Array<GField1> ArrayOfGField1;
typedef Array<GField2> ArrayOfGField2;
typedef Array<GField3> ArrayOfGField3;
typedef Array<GField4> ArrayOfGField4;
typedef Array< Array<GField1> > ArrayOfArrayOfGField1;
typedef Array< Array<GField3> > ArrayOfArrayOfGField3;

#endif

---