CutoffFunction.h

Go to the documentation of this file.

// n2p2 - A neural network potential package
// Copyright (C) 2018 Andreas Singraber (University of Vienna)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef CUTOFFFUNCTION_H
#define CUTOFFFUNCTION_H
 
#include "CoreFunction.h"
 
namespace nnp
{
 
class CutoffFunction
{
public:
    enum CutoffType
    {
        CT_HARD,
        CT_COS,
        CT_TANHU,
        CT_TANH,
        CT_EXP,
        CT_POLY1,
        CT_POLY2,
        CT_POLY3,
        CT_POLY4
    };
 
    CutoffFunction();
    void       setCutoffType(CutoffType const cutoffType);
    CutoffType getCutoffType() const;
    void       setCutoffRadius(double const cutoffRadius);
    double     getCutoffRadius() const;
    void       setCutoffParameter(double const alpha);
    double     getCutoffParameter() const;
    double     f(double r) const;
    double     df(double r) const;
    void       fdf(double r, double& fc, double& dfc) const;
 
private:
    static double const PI;
    static double const PI_2;
    static double const E;
    static double const TANH_PRE;
 
    CutoffType   cutoffType;
    double       rc;
    double       rcinv;
    double       rci;
    double       alpha;
    double       iw;
    CoreFunction core;
    double       (CutoffFunction::*fPtr)(double r) const;
    double       (CutoffFunction::*dfPtr)(double r) const;
    void         (CutoffFunction::*fdfPtr)(double  r,
                                           double& fc,
                                           double& dfc) const;
 
    // Individual cutoff functions.
    double   fHARD (double r) const;
    double  dfHARD (double r) const;
    void   fdfHARD (double r, double& fc, double& dfc) const;
 
    double   fCOS  (double r) const;
    double  dfCOS  (double r) const;
    void   fdfCOS  (double r, double& fc, double& dfc) const;
 
    double   fTANHU(double r) const;
    double  dfTANHU(double r) const;
    void   fdfTANHU(double r, double& fc, double& dfc) const;
 
    double   fTANH (double r) const;
    double  dfTANH (double r) const;
    void   fdfTANH (double r, double& fc, double& dfc) const;
 
    double   fCORE (double r) const;
    double  dfCORE (double r) const;
    void   fdfCORE (double r, double& fc, double& dfc) const;
};
 
// Inlined function definitions //
 
inline CutoffFunction::CutoffType CutoffFunction::getCutoffType() const
{
    return cutoffType;
}
 
inline double CutoffFunction::getCutoffRadius() const
{
    return rc;
}
 
inline double CutoffFunction::getCutoffParameter() const
{
    return alpha;
}
 
inline double CutoffFunction::f(double r) const
{
    if (r >= rc) return 0.0;
    return (this->*fPtr)(r);
}
 
inline double CutoffFunction::df(double r) const
{
    if (r >= rc) return 0.0;
    return (this->*dfPtr)(r);
}
 
inline void CutoffFunction::fdf(double r, double& fc, double& dfc) const
{
    if (r >= rc)
    {
        fc = 0.0;
        dfc = 0.0;
        return;
    }
    (this->*fdfPtr)(r, fc, dfc);
    return;
}
 
inline double CutoffFunction::fHARD(double /*r*/) const
{
    return 1.0;
}
 
inline double CutoffFunction::dfHARD(double /*r*/) const
{
    return 0.0;
}
 
inline void CutoffFunction::fdfHARD(double /*r*/,
                                    double& fc,
                                    double& dfc) const
{
    fc = 1.0;
    dfc = 0.0;
    return;
}
 
}
 
#endif