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(
            "fromString() not supported in this VariableConverter");
    }
 
    static VariableConverter* createVariableConverter(XDOMElement& child);
 
    static VariableConverter* createFromString(const std::string&);
 
    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*);
 
    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);
 
    virtual std::string toString() const override;
 
    void fromString(const std::string&);
 
    void fromDOMElement(const xercesc::DOMElement*);
 
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);
 
    virtual std::string toString() const override;
 
    void fromString(const std::string&);
 
    void fromDOMElement(const xercesc::DOMElement*);
 
    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