tension_function.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef ECL_GEOMETRY_TENSION_FUNCTION_HPP_
#define ECL_GEOMETRY_TENSION_FUNCTION_HPP_
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
#include "function_math.hpp"
#include <ecl/config/macros.hpp>
#include <ecl/concepts/macros.hpp>
#include <ecl/concepts/streams.hpp>
#include <ecl/containers/array.hpp>
#include <ecl/errors/compile_time_assert.hpp>
#include <ecl/utilities/blueprints.hpp>
#include <ecl/formatters/floats.hpp>
 
/*****************************************************************************
** Namespaces
*****************************************************************************/
 
namespace ecl {
 
/*****************************************************************************
** Forward Declarations
*****************************************************************************/
 
class TensionFunction;
 
namespace blueprints {
 
class TensionSecondDerivativeInterpolation;
 
} // namespace blueprints
 
/*****************************************************************************
** BluePrintFactory
*****************************************************************************/
template<>
class ECL_PUBLIC BluePrintFactory< TensionFunction > {
    public:
        static blueprints::TensionSecondDerivativeInterpolation Interpolation(const double x_i, const double y_i, const double yddot_i,
                const double x_f, const double y_f, const double yddot_f);
 
        virtual ~BluePrintFactory() {};
};
 
/*****************************************************************************
** Interface [TensionFunction]
*****************************************************************************/
class ECL_PUBLIC TensionFunction : public BluePrintFactory< TensionFunction > {
    public:
        /*********************
        ** Constructors
        **********************/
        TensionFunction() {}
        virtual ~TensionFunction() {}
        template<typename Derived>
        TensionFunction(const BluePrint< Derived > &blueprint) {
            blueprint.implementApply(*this);
        }
 
        /*********************
        ** Derivatives
        **********************/
        double derivative(const double &tau, const double &x) const;
 
        double dderivative(const double &tau, const double &x) const;
 
        /*********************
        ** Accessors
        **********************/
        double operator ()(const double &tau, const double &x) const;
 
        /*********************
        ** Friends
        **********************/
        friend class blueprints::TensionSecondDerivativeInterpolation;
 
 
        template <typename OutputStream>
        friend OutputStream& operator << (OutputStream &ostream, const TensionFunction &function);
 
    private:
        double z_0, z_f; // yddot_0, yddot_f
        double x_0, x_f;
        double y_0, y_f;
};
 
 
/*****************************************************************************
** Streaming Operator [TensionFunction]
*****************************************************************************/
template <typename OutputStream>
OutputStream& operator << (OutputStream &ostream, const TensionFunction &function)
{
        ecl_compile_time_concept_check(StreamConcept<OutputStream>);
 
    Format<double> format;
    format.precision(2);
    double h = function.x_f - function.x_0;
    if ( ( function.z_0 == 0.0 ) && ( function.z_f == 0.0 ) ) {
        ostream << "0.0";
    } else {
        ostream << "{";
        if ( function.z_0 != 0.0 ) {
            ostream << format(function.z_0) << "*sinh[tau(";
            ostream << format(function.x_f) << "-x)] + ";
        }
        if ( function.z_f != 0.0 ) {
            ostream << format(function.z_f) << "*sinh[tau(x-";
            ostream << format(function.x_0) << ")]}/[tau^2 sinh(";
            ostream << format(function.x_f - function.x_0) << "*tau)]";
        }
    }
    ostream << "\n";
    ostream << "        + (";
    ostream << format(function.y_0/h) << "-";
    ostream << format(function.z_0/h) << "/tau^2)(";
    ostream << format(function.x_f) << "-x)\n";
    ostream << "                    + (";
    ostream << format(function.y_f/h) << "-";
    ostream << format(function.z_f/h) << "/tau^2)(x-";
    ostream << format(function.x_0) << ")\n";
    ostream.flush();
 
    return ostream;
}
 
/*****************************************************************************
** BluePrints
*****************************************************************************/
 
namespace blueprints {
 
/*****************************************************************************
** Interface [TensionSecondDerivativeInterpolation]
*****************************************************************************/
 
class ECL_PUBLIC TensionSecondDerivativeInterpolation : public ecl::BluePrint<TensionSecondDerivativeInterpolation> {
    public:
        typedef ecl::TensionFunction base_type;
        TensionSecondDerivativeInterpolation(const double x_i, const double y_i, const double yddot_i,
                const double x_f, const double y_f, const double yddot_f) :
                    x_initial(x_i),
                    y_initial(y_i),
                    yddot_initial(yddot_i),
                    x_final(x_f),
                    y_final(y_f),
                    yddot_final(yddot_f)
        {}
        virtual ~TensionSecondDerivativeInterpolation() {}
 
        ecl::TensionFunction instantiate();
 
        void apply(base_type& function) const;
 
    private:
        double x_initial, y_initial, yddot_initial;
        double x_final, y_final, yddot_final;
};
 
 
}; // namespace blueprints
}; // namespace ecl
 
#endif /*ECL_GEOMETRY_TENSION_FUNCTION_HPP_*/