pair6_12RDFIntegrator.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: pair6_12RDFIntegrator.h,v 1.24 2005/12/23 17:01:59 amoll Exp $
//

#ifndef BALL_SOLVATION_PAIR6_12RDFINTEGRATOR_H
#define BALL_SOLVATION_PAIR6_12RDFINTEGRATOR_H

#ifndef BALL_STRUCTURE_RDFINTEGRATOR_H
# include <BALL/STRUCTURE/RDFIntegrator.h>
#endif

#ifndef BALL_MATHS_PIECEWISEFUNCTION_H
# include <BALL/MATHS/piecewiseFunction.h>
#endif

#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif

// ?????: DOCU ... documentation for constants

namespace BALL
{
  class BALL_EXPORT Pair6_12RDFIntegrator
    : public RDFIntegrator
  {
    public:

    BALL_CREATE(Pair6_12RDFIntegrator)

    
    struct BALL_EXPORT Option
    {
      static const char* METHOD;

      static const char* SAMPLES;

      static const char* VERBOSITY;
    };

    struct BALL_EXPORT Default
    {
      static const Size VERBOSITY;
      
      static const Size METHOD;

      static const Size SAMPLES;
    };

    enum IntegrationMethod
    {
      METHOD__UNKNOWN = 0,
      METHOD__ANALYTICAL = 1,
      METHOD__TRAPEZIUM = 2
    };


    Pair6_12RDFIntegrator();

    Pair6_12RDFIntegrator(const Pair6_12RDFIntegrator& integrator);

    Pair6_12RDFIntegrator(double A, double B, double k1, double k2,
        const RadialDistributionFunction& rdf);

    virtual ~Pair6_12RDFIntegrator();



    const Pair6_12RDFIntegrator& operator =
      (const Pair6_12RDFIntegrator& integrator);

    virtual void clear();




    void setConstants(double A, double B, double k1, double k2);

    void getConstants(double& A, double& B, double& k1, double& k2);

    double integrateToInf(double from) const;

    double integrateToInf(double from, double A, double B, double k1,
        double k2);

    double integrate(double from, double to) const;
    
    double integrate(double from, double to, double A, double B, double k1,
        double k2);

    virtual double operator () (double x) const;



    bool operator == (const Pair6_12RDFIntegrator& integrator) const;


    Options options;



    virtual void dump (std::ostream& s = std::cout, Size depth = 0) const;
    

    protected:

    /*_ Repulsion constant 
    */
    double A_;

    /*_ Dispersion constant 
    */
    double B_;

    /*_ Geometry constant 
    */
    double k1_;

    /*_ Geometry constant 
    */
    double k2_;


    private:

    /*_ Integrate an interval analytically. This method does the actual work. 
        @param interval the interval to be integrated
        @param coeffs the coefficients for this interval
        @param x0 the value to be subtracted from x
        @return the value of the integral
    */
    double analyticallyIntegrateInterval(const Interval& interval,
        const Coefficients& coeffs, float x0) const;

    /*_ Integrate an interval numerically.
        @param interval the interval to be integrated
        @return the value of the integral
    */
    double numericallyIntegrateInterval(const Interval& interval) const;

    /*_ Project a number from the integration beam to the projection beam
        of an atom center for the rdf thingy. 
        @param x the value to be projected
        @return the projection of <b>  x </b>
    */
    double project(double x) const;

    /*_ Do the reverse of project(). 
        @param x the valut to be reversly projected
        @return the projection of <b>  x </b>
    */
    double unproject(double x) const;
  };
   
} // namespace BALL

#endif //  BALL_SOLVATION_PAIR6_12RDFINTEGRATOR_H

---