QuadratureIntegrator1D.h

#ifndef QUADRATURE_INTEGRATOR_1D_H_
#define QUADRATURE_INTEGRATOR_1D_H_

/**
 * @file QuadratureIntegrator1D.h
 * @author Bryan BERTHOU (SPhN / CEA Saclay)
 * @date 15 February 2016
 * @version 1.0
 */

#include <ElementaryUtils/parameters/Parameters.h>
#include <string>
#include <vector>

#include "Integrator1DModule.h"

namespace NumA {
class FunctionType1D;
} /* namespace NumA */

class FunctionType1D;

namespace NumA {

/**
 * @class QuadratureIntegrator1D
 *
 * @brief Abstract quadrature class (for fixed quadrature rules).
 *
 * Child classes must define a way to compute the nodes \f$ x_i \f$ and weights \f$ w_i \f$.\n
 * The integration itself is done by this abstract class:
 * \f$ \displaystyle \int_a^b f\left(x\right) \mathrm{d}x = \sum_{i=0}^{N-1} w_i f\left(x_i\right) \f$, through the integrate() routine.
 *
 * See Integrator1D documentation for an example.
 */

class QuadratureIntegrator1D: public Integrator1DModule {
public:
    static const std::string PARAM_NAME_N; ///< Parameter used in the configure() to set the order of the quadrature.

    /**
     * Constructor.
     * See BaseObject::BaseObject and ModuleObject::ModuleObject for more details.
     *
     * @param className name of child class.
     */
    QuadratureIntegrator1D(const std::string &className);

//    /**
//     * Constructor.
//     * @param N Order of the quadrature (number of nodes).
//     */
//    QuadratureIntegrator1D(unsigned int N = 0);

    /**
     * Default destructor.
     */
    virtual ~QuadratureIntegrator1D();

    virtual QuadratureIntegrator1D* clone() const = 0;

    virtual double integrate(FunctionType1D* pFunction, double a, double b,
            std::vector<double> &parameters);

    virtual void configure(const ElemUtils::Parameters &parameters);

    /**
     *
     * @return Order of the quadrature (number of nodes).
     */
    unsigned int getN() const;
    /**
     *
     * @param n Order of the quadrature (number of nodes).
     */
    virtual void setN(unsigned int n) = 0;
    /**
     *
     * @return Nodes of the quadrature.
     */
    const std::vector<double>& getNodes() const;
    /**
     *
     * @return Weights of the quadrature.
     */
    const std::vector<double>& getWeights() const;

protected:
    unsigned int m_N; ///< Order of the quadrature (number of nodes).
    std::vector<double> m_nodes; ///< Nodes of the quadrature.
    std::vector<double> m_weights; ///< Weights of the quadrature.

    /**
     * Copy constructor.
     * Called by clone().
     * @param other QuadratureIntegrator1D object to copy.
     */
    QuadratureIntegrator1D(const QuadratureIntegrator1D &other);

    virtual void setNodesAndWeights() = 0;

    virtual void isModuleWellConfigured();
    virtual void initModule();
};

} // namespace NumA

#endif /* QUADRATURE_INTEGRATOR_1D_H_ */