sub_state_vector_array.h

Go to the documentation of this file.

#ifndef SUB_STATE_VECTOR_ARRAY_H
#define SUB_STATE_VECTOR_ARRAY_H
#include "sub_state_vector_observer.h"
#include "pressure.h"
#include <boost/lexical_cast.hpp>

namespace FullPhysics {
/****************************************************************/
template<class Base> class SubStateVectorArray:
    virtual public Base,
    public SubStateVectorObserver {
public:
    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    SubStateVectorArray(const blitz::Array<double, 1>& Coeff,
                        const blitz::Array<bool, 1>& Used_flag,
                        const boost::shared_ptr<Pressure>& Press = boost::shared_ptr<Pressure>(),
                        bool Mark_according_to_press = true,
                        int Pdep_start = 0)
        : coeff(Coeff.copy()), press(Press), used_flag(Used_flag.copy()),
          mark_according_to_press(Mark_according_to_press),
          pdep_start(Pdep_start)
    {
        if(coeff.rows() != used_flag.rows()) {
            throw Exception("Coeff and Used_flag need to be the same size");
        }

        state_vector_observer_initialize(count(Used_flag));
    }

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    SubStateVectorArray() {}

    void init(const blitz::Array<double, 1>& Coeff,
              const blitz::Array<bool, 1>& Used_flag,
              const boost::shared_ptr<Pressure>& Press = boost::shared_ptr<Pressure>(),
              bool Mark_according_to_press = true,
              int Pdep_start = 0)
    {
        mark_according_to_press = Mark_according_to_press;
        pdep_start = Pdep_start;
        coeff.reference(Coeff.copy());
        press = Press;
        used_flag.reference(Used_flag.copy());

        if(coeff.rows() != used_flag.rows()) {
            throw Exception("Coeff and Used_flag need to be the same size");
        }

        state_vector_observer_initialize(count(Used_flag));
    }

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    SubStateVectorArray(double Coeff, bool Used_flag)
        : coeff(1, 0), used_flag(1)
    {
        coeff.value()(0) = Coeff;
        used_flag(0) = Used_flag;
        state_vector_observer_initialize(count(used_flag));
    }

    virtual ~SubStateVectorArray() {}
    void mark_used_sub(blitz::Array<bool, 1>& Used) const
    {
        int si = 0;

        for(int i = 0; i < used_flag.rows(); ++i) {
            if(used_flag(i)) {
                if(!press || !mark_according_to_press ||
                        i < press->number_level() + pdep_start) {
                    Used(si) = true;
                }

                ++si;
            }
        }
    }


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    virtual std::string sub_state_identifier() const
    {
        return "unknown/not_set";
    }

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    virtual std::string state_vector_name_i(int i) const
    {
        return "Coeff" + boost::lexical_cast<std::string>(i + 1);
    }

    virtual void state_vector_name_sub(blitz::Array<std::string, 1>& Sv_name) const
    {
        int si = 0;

        for(int i = 0; i < used_flag.rows(); ++i)
            if(used_flag(i)) {
                Sv_name(si) = state_vector_name_i(i);
                ++si;
            }
    }

    virtual void update_sub_state(const ArrayAd<double, 1>& Sv_sub, const blitz::Array<double, 2>& Cov)
    {
        if (Sv_sub.rows() > 0) {
            cov.reference(Cov.copy());
            int si = 0;
            coeff.resize_number_variable(Sv_sub.number_variable());

            for(int i = 0; i < coeff.rows(); ++i)
                if(used_flag(i)) {
                    coeff(i) = Sv_sub(si);
                    ++si;
                }
        }

        update_sub_state_hook();
        Observable<Base>::notify_update_do(*this);
    }

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    virtual void update_sub_state_hook()
    {
    }

    const ArrayAd<double, 1>& coefficient() const
    {
        return coeff;
    }

    const blitz::Array<bool, 1>& used_flag_value() const
    {
        return used_flag;
    }

    const blitz::Array<double, 2>& statevector_covariance() const
    {
        return cov;
    }

    const boost::shared_ptr<Pressure>& pressure() const
    {
        return press;
    }
protected:

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    ArrayAd<double, 1> coeff;

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    boost::shared_ptr<Pressure> press;

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    blitz::Array<bool, 1> used_flag;

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    blitz::Array<double, 2> cov;

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    bool mark_according_to_press;

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------

    int pdep_start;
};
}
#endif