ToVLevelConverter.h

Go to the documentation of this file.

/*
 * Fimex, ToVLevelConverter.h
 *
 * (C) Copyright 2011, met.no
 *
 * Project Info:  https://wiki.met.no/fimex/start
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 *
 *  Created on: Aug 9, 2011
 *      Author: Heiko Klein
 */

#ifndef TO_VLEVEL_CONVERTER_H_
#define TO_VLEVEL_CONVERTER_H_

#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/shared_array.hpp>
#include <boost/noncopyable.hpp>
#include "fimex/coordSys/CoordinateSystem.h"
#include "fimex/mifi_constants.h"
#include "fimex/IndexedData.h"
#include "fimex/deprecated.h"

namespace MetNoFimex
{
// forward decl.
class CDMReader;

using namespace std;

class ToVLevelConverter : boost::noncopyable {
public:
    virtual ~ToVLevelConverter() {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t) = 0;

    inline vector<double> values(size_t x, size_t y, size_t t)
        { return operator()(x, y, t); }

    virtual bool isValid(double val, size_t x, size_t y, size_t t);
};

class IdentityToVLevelConverter : public ToVLevelConverter {
    const vector<double> vlevel_;
public:
    IdentityToVLevelConverter(const vector<double>& vlevel) : vlevel_(vlevel) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class Identity4DToVLevelConverter : public ToVLevelConverter {
    const boost::shared_array<float> pressure_;
    size_t nx_;
    size_t ny_;
    size_t nz_;
    size_t nt_;
public:
    Identity4DToVLevelConverter(const boost::shared_array<float> pressure, size_t nx, size_t ny, size_t nk, size_t nt)
        : pressure_(pressure), nx_(nx), ny_(ny), nz_(nk), nt_(nt) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class LnPressureToPressureConverter : public ToVLevelConverter {
    vector<double> pres_;
public:
    LnPressureToPressureConverter(double p0, const vector<double>& lnP);
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class AltitudeStandardToPressureConverter : public ToVLevelConverter {
    vector<double> pres_;
public:
    AltitudeStandardToPressureConverter(const vector<double>& h);
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class SigmaToPressureConverter : public ToVLevelConverter {
    const vector<double> sigma_;
    double ptop_;
    const boost::shared_array<double> ps_;
    size_t nx_;
    size_t ny_;
    size_t nt_;
public:
    SigmaToPressureConverter(const vector<double>& sigma, double ptop, const boost::shared_array<double> ps, size_t nx, size_t ny, size_t nt)
    : sigma_(sigma), ptop_(ptop), ps_(ps), nx_(nx), ny_(ny), nt_(nt) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};


class HybridSigmaApToPressureConverter : public ToVLevelConverter {
    const vector<double> ap_;
    const vector<double> b_;
    const boost::shared_array<double> ps_;
    size_t nx_;
    size_t ny_;
    size_t nt_;
public:
    HybridSigmaApToPressureConverter(const vector<double>& ap, const vector<double>& b, const boost::shared_array<double> ps, size_t nx, size_t ny, size_t nt)
    : ap_(ap), b_(b), ps_(ps), nx_(nx), ny_(ny), nt_(nt) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class HybridSigmaToPressureConverter : public ToVLevelConverter {
    const vector<double> a_;
    const vector<double> b_;
    double p0_;
    const boost::shared_array<double> ps_;
    size_t nx_;
    size_t ny_;
    size_t nt_;
public:
    HybridSigmaToPressureConverter(const vector<double>& a, const vector<double>& b, double p0, const boost::shared_array<double> ps, size_t nx, size_t ny, size_t nt)
    : a_(a), b_(b), p0_(p0), ps_(ps), nx_(nx), ny_(ny), nt_(nt) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class PressureToStandardAltitudeConverter : public ToVLevelConverter {
    const boost::shared_ptr<ToVLevelConverter> presConv_;
public:
    PressureToStandardAltitudeConverter(boost::shared_ptr<ToVLevelConverter> presConv) : presConv_(presConv) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class PressureIntegrationToAltitudeConverter : public ToVLevelConverter {
    const boost::shared_ptr<ToVLevelConverter> presConv_;
    typedef const boost::shared_array<float> float_cp;
    float_cp surface_air_pressure_, surface_geopotential_, air_temperature_, specific_humidity_;
    size_t nx_, ny_, nt_;

public:
    PressureIntegrationToAltitudeConverter(boost::shared_ptr<ToVLevelConverter> pressure,
            float_cp sapVal, float_cp sgpVal, float_cp airtVal, float_cp shVal,
            size_t nx, size_t ny, size_t nt);
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class AltitudeConverterToHeightConverter : public ToVLevelConverter {
    const boost::shared_ptr<ToVLevelConverter> conv_;
    const boost::shared_array<float> topo_;
    size_t nx_;
    size_t ny_;
    size_t nz_;
    size_t nt_;
public:
    AltitudeConverterToHeightConverter(const boost::shared_ptr<ToVLevelConverter> altiConverter, const boost::shared_array<float> topography, size_t nx, size_t ny, size_t nk, size_t nt)
    : conv_(altiConverter), topo_(topography), nx_(nx), ny_(ny), nz_(nk), nt_(nt) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};

class HeightConverterToAltitudeConverter : public ToVLevelConverter {
    const boost::shared_ptr<ToVLevelConverter> conv_;
    const boost::shared_array<float> topo_;
    size_t nx_;
    size_t ny_;
    size_t nz_;
    size_t nt_;
public:
    HeightConverterToAltitudeConverter(const boost::shared_ptr<ToVLevelConverter> heightConverter, const boost::shared_array<float> topography, size_t nx, size_t ny, size_t nk, size_t nt)
    : conv_(heightConverter), topo_(topography), nx_(nx), ny_(ny), nz_(nk), nt_(nt) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};


class GeopotentialToAltitudeConverter : public ToVLevelConverter {
    const boost::shared_array<float> geopot_;
    size_t nx_;
    size_t ny_;
    size_t nz_;
    size_t nt_;
public:
    GeopotentialToAltitudeConverter(const boost::shared_array<float> geopot_height, size_t nx, size_t ny, size_t nk, size_t nt)
    : geopot_(geopot_height), nx_(nx), ny_(ny), nz_(nk), nt_(nt) {}
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
};


class OceanSCoordinateGToDepthConverter : public ToVLevelConverter {
    vector<double> s_;
    vector<double> C_;
    double depth_c_;
    const IndexedData eta_;
    const IndexedData depth_;
    /* eta might be 0 */
    size_t nx_;
    size_t ny_;
    size_t nz_;
    size_t nt_;
    bool timeDependentDepth_;
    int (*func_)(size_t, double, double, double, const double*, const double*, double*);

public:
    OceanSCoordinateGToDepthConverter(const vector<double>& s, const vector<double>& C, double depth_c,
                                      IndexedData eta, IndexedData depth,
                                      size_t nx, size_t ny, size_t nk, size_t nt,
                                      int (*func)(size_t, double, double, double, const double*, const double*, double*))
    : s_(s), C_(C), depth_c_(depth_c), eta_(eta), depth_(depth),
      nx_(nx), ny_(ny), nz_(nk), nt_(nt)
    {
            timeDependentDepth_ = (depth_.idx().getDims().size() == 3);
            func_ = func;
    }
    virtual vector<double> operator()(size_t x, size_t y, size_t t);
    virtual bool isValid(double val, size_t x, size_t y, size_t t);
};

} // namespace

#endif /* TO_VLEVEL_CONVERTER_H_ */