FEBio/LoadCurve.h

// LoadCurve.h: interface for the LoadCurve class.
//

#if !defined(AFX_LOADCURVE_H__E2D23AD8_1961_49E7_BE3A_3FC885CED53D__INCLUDED_)
#define AFX_LOADCURVE_H__E2D23AD8_1961_49E7_BE3A_3FC885CED53D__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "DumpFile.h"
#include <vector>

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


class FELoadCurve
{
public:
        struct LOADPOINT
        {
                double time;
                double value;
        };

public:
        enum INTFUNC { STEP=0, LINEAR=1, SMOOTH=2 };

        enum EXTMODE { CONSTANT, EXTRAPOLATE, REPEAT, REPEAT_OFFSET };

public:
        FELoadCurve() : m_fnc(LINEAR), m_ext(CONSTANT) {}

        FELoadCurve(const FELoadCurve& LC);

        FELoadCurve& operator = (const FELoadCurve& LC);

        virtual ~FELoadCurve() {}

        void Create(int n);

        void Add(double time, double value);

        void Clear() { m_lp.clear(); }

        void SetPoint(int i, double time, double val);

        double Value(double time) const;
        double Value() const { return m_value; }

        double Deriv(double time) const;

        void Evaluate(double time)
        {
                m_value = Value(time);
        }

        void SetInterpolation(INTFUNC fnc) { m_fnc = fnc; }

        void SetExtendMode(EXTMODE mode) { m_ext = mode; }

        LOADPOINT& LoadPoint(int i) { return m_lp[i]; }

        int FindPoint(double t);

        int Points() const { return m_lp.size(); }

        bool HasPoint(double t) const;

        void Serialize(DumpFile& ar);

protected:
        double ExtendValue(double t) const;

protected:
        std::vector<LOADPOINT>  m_lp;   

        double                  m_value;        

        INTFUNC         m_fnc;  
        EXTMODE         m_ext;  
};

typedef FELoadCurve::LOADPOINT LOADPOINT;

#endif // !defined(AFX_LOADCURVE_H__E2D23AD8_1961_49E7_BE3A_3FC885CED53D__INCLUDED_)