Lau1DCubicSpline.hh

Go to the documentation of this file.

/*
Copyright 2015 University of Warwick

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

/*
Laura++ package authors:
John Back
Paul Harrison
Thomas Latham
*/

#ifndef LAU_1DCUBICSPLINE
#define LAU_1DCUBICSPLINE

#include <vector>

#include "Rtypes.h"

class Lau1DCubicSpline {

        public:
                enum LauSplineType {
                        StandardSpline, 
                        AkimaSpline, 
                        LinearInterpolation 
                };


                enum LauSplineBoundaryType {
                        Clamped, 
                        Natural, 
                        NotAKnot 
                };


                Lau1DCubicSpline(const std::vector<Double_t>& xs, const std::vector<Double_t>& ys,
                                 LauSplineType type = Lau1DCubicSpline::StandardSpline,
                                 LauSplineBoundaryType leftBound = Lau1DCubicSpline::NotAKnot, 
                                 LauSplineBoundaryType rightBound = Lau1DCubicSpline::NotAKnot,
                                 Double_t dydx0 = 0.0, Double_t dydxn = 0.0);

                virtual ~Lau1DCubicSpline();


                Double_t evaluate(Double_t x) const;


                void updateYValues(const std::vector<Double_t>& ys);


                void updateType(LauSplineType type);


                void updateBoundaryConditions(LauSplineBoundaryType leftBound, 
                                              LauSplineBoundaryType rightBound, 
                                              Double_t dydx0 = 0.0,
                                              Double_t dydxn = 0.0);

        private:
                Lau1DCubicSpline( const Lau1DCubicSpline& rhs );

                Lau1DCubicSpline& operator=(const Lau1DCubicSpline& rhs);

                void init();

                void calcDerivatives();

                void calcDerivativesStandard();
                void calcDerivativesAkima();

                const UInt_t nKnots_;

                std::vector<Double_t> x_;
                std::vector<Double_t> y_;
                std::vector<Double_t> dydx_;

                std::vector<Double_t> a_;
                std::vector<Double_t> b_;
                std::vector<Double_t> c_;
                std::vector<Double_t> d_;

                LauSplineType type_;

                LauSplineBoundaryType leftBound_;
                LauSplineBoundaryType rightBound_;

                Double_t dydx0_;
                Double_t dydxn_;

                ClassDef(Lau1DCubicSpline, 0); // Class for defining a 1D cubic spline
};

#endif