VariableConverter.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2005, Copyright University Corporation for Atmospheric Research
 **
 ** 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 of the License, 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.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/

#ifndef NIDAS_CORE_VARIABLECONVERTER_H
#define NIDAS_CORE_VARIABLECONVERTER_H

#include "DOMable.h"
#include "Sample.h"
#include "Parameter.h"

#include <string>
#include <vector>

namespace nidas { namespace core {

class DSMConfig;
class DSMSensor;
class CalFile;
class Variable;

class CalFileHandler
{
public:
    CalFileHandler()
    {}

    virtual bool handleCalFileRecord(nidas::core::CalFile*) = 0;

    virtual ~CalFileHandler() {}
};


class VariableConverter: public DOMable
{
public:

    VariableConverter();

    VariableConverter(const VariableConverter& x);

    VariableConverter& operator=(const VariableConverter& x);

    virtual ~VariableConverter();

    virtual VariableConverter* clone() const = 0;

    virtual void readCalFile(dsm_time_t) throw();

    void setCalFileHandler(CalFileHandler*);

    virtual double convert(dsm_time_t,double v) = 0;

    void setUnits(const std::string& val) { _units = val; }

    virtual const std::string& getUnits() const { return _units; }

    void setVariable(const Variable* val) { _variable = val; }

    const Variable* getVariable() const { return _variable; }

    virtual void reset() = 0;

    const DSMSensor* getDSMSensor() const;

    const DSMConfig* getDSMConfig() const;

    virtual std::string toString() const = 0;

    virtual void fromString(const std::string&)
        throw(nidas::util::InvalidParameterException) {
        throw nidas::util::InvalidParameterException(
            "fromString() not supported in this VariableConverter");
    }

    static VariableConverter* createVariableConverter(
        XDOMElement& child);

    static VariableConverter* createFromString(const std::string&)
        throw(nidas::util::InvalidParameterException);

    void addParameter(Parameter* val);

    const std::list<const Parameter*>& getParameters() const
    {
    return _constParameters;
    }

    const Parameter* getParameter(const std::string& name) const;

    void fromDOMElement(const xercesc::DOMElement*)
        throw(nidas::util::InvalidParameterException);

    void setCalFile(CalFile*);

    CalFile* getCalFile()
    {
        return _calFile;
    }

    const CalFile* getCalFile() const
    {
        return _calFile;
    }

private:

    std::string _units;

    std::map<std::string,Parameter*> _parameters;

    std::list<const Parameter*> _constParameters;

    const Variable* _variable;

protected:
    
    virtual void parseFields(CalFile* cf) = 0;

    void abortCalFile(const std::string& what);

    CalFile* _calFile;

    CalFileHandler* _handler;
};

class Linear: public VariableConverter
{
public:

    Linear();

    Linear* clone() const;

    void setSlope(float val) { _slope = val; }

    float getSlope() const { return _slope; }

    void setIntercept(float val) { _intercept = val; }

    float getIntercept() const { return _intercept; }

    double convert(dsm_time_t t, double val);

    void reset();

    void parseFields(CalFile* cf);

    std::string toString() const;

    void fromString(const std::string&)
        throw(nidas::util::InvalidParameterException);

    void fromDOMElement(const xercesc::DOMElement*)
        throw(nidas::util::InvalidParameterException);

private:

    float _slope;

    float _intercept;

};

class Polynomial: public VariableConverter
{
public:

    Polynomial();

    Polynomial* clone() const;

    void setCoefficients(const std::vector<float>& vals);

    void setCoefficients(const float* fp, unsigned int n);

    const std::vector<float>& getCoefficients() const { return _coefs; }

    const float* getCoefficients(unsigned int & n) const
    {
        n = _coefs.size();
        return &_coefs[0];
    }

    double convert(dsm_time_t t,double val);

    void reset();

    void parseFields(CalFile* cf);

    std::string toString() const;

    void fromString(const std::string&)
        throw(nidas::util::InvalidParameterException);

    void fromDOMElement(const xercesc::DOMElement*)
        throw(nidas::util::InvalidParameterException);

    static double eval(double x,float *p, unsigned int np);

private:

    std::vector<float> _coefs;
};

/* static */
inline double Polynomial::eval(double x,float *p, unsigned int np)
{
    double y = 0.0;
    if (np == 0) return y;
    for (unsigned int i = np - 1; i > 0; i--) {
        y += p[i];
        y *= x;
    }
    y += p[0];
    return y;
}


template <class F>
class CalFileHandlerFunction : public CalFileHandler
{
public:
    CalFileHandlerFunction(F& fo) : _handler(fo)
    {}

    virtual bool
    handleCalFileRecord(nidas::core::CalFile* cf)
    {
        return _handler(cf);
    }

    F _handler;
};

template <class F>
CalFileHandler*
makeCalFileHandler(F _fo)
{
    return new CalFileHandlerFunction<F>(_fo);
}


}}  // namespace nidas namespace core

#endif