SymFncBaseCompAngWeighted.cpp

Go to the documentation of this file.

// n2p2 - A neural network potential package
// Copyright (C) 2018 Andreas Singraber (University of Vienna)
// Copyright (C) 2020 Martin P. Bircher
//
// 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/>.
 
#include "SymFncBaseCompAngWeighted.h"
#include "Atom.h"
#include "ElementMap.h"
#include "utility.h"
#include "Vec3D.h"
#include <cstdlib>   // atof, atoi
#include <cmath>     // exp, pow, cos
#include <limits>    // std::numeric_limits
#include <stdexcept> // std::runtime_error
 
using namespace std;
using namespace nnp;
 
SymFncBaseCompAngWeighted::
SymFncBaseCompAngWeighted(size_t type, ElementMap const& elementMap) :
    SymFncBaseComp(type, elementMap),
    angleLeft        (0.0),
    angleRight       (0.0),
    angleLeftRadians (0.0),
    angleRightRadians(0.0)
{
    minNeighbors = 2;
    parameters.insert("angleLeft");
    parameters.insert("angleRight");
}
 
void SymFncBaseCompAngWeighted::setParameters(string const& parameterString)
{
    vector<string> splitLine = split(reduce(parameterString));
 
    if (type != (size_t)atoi(splitLine.at(1).c_str()))
    {
        throw runtime_error("ERROR: Incorrect symmetry function type.\n");
    }
 
    ec         = elementMap[splitLine.at(0)];
    rl         = atof(splitLine.at(2).c_str());
    rc         = atof(splitLine.at(3).c_str());
    angleLeft  = atof(splitLine.at(4).c_str());
    angleRight = atof(splitLine.at(5).c_str());
    subtype    = splitLine.at(6);
 
    // Radial part.
    if (rl > rc)
    {
        throw runtime_error("ERROR: Lower radial boundary >= upper "
                            "radial boundary.\n");
    }
    //if (rl < 0.0 && abs(rl + rc) > numeric_limits<double>::epsilon())
    //{
    //    throw runtime_error("ERROR: Radial function not symmetric "
    //                        "w.r.t. origin.\n");
    //}
   
    setCompactFunction(subtype);
    cr.setLeftRight(rl,rc);
 
    // Angular part.
    if (angleLeft >= angleRight)
    {
        throw runtime_error("ERROR: Left angle boundary right of or equal to "
                            "right angle boundary.\n");
    }
 
    double const center = (angleLeft + angleRight) / 2.0;
    if ( (angleLeft  <   0.0 && center != 0.0) ||
         (angleRight > 180.0 && center != 180.0) )
    {
        throw runtime_error("ERROR: Angle boundary out of [0,180] and "
                            "center of angular function /= 0 or /= 180.\n");
    }
    if (angleRight - angleLeft > 360.0)
    {
        throw runtime_error("ERROR: Periodic symmetry function cannot spread "
                            "over domain > 360 degrees\n");
    }
 
    ca.setCoreFunction(cr.getCoreFunctionType());
    angleLeftRadians = angleLeft * M_PI / 180.0;
    angleRightRadians = angleRight * M_PI / 180.0;
    ca.setLeftRight(angleLeftRadians, angleRightRadians);
 
    return;
}
 
void SymFncBaseCompAngWeighted::changeLengthUnit(double convLength)
{
    this->convLength = convLength;
    rc *= convLength;
    rl *= convLength;
 
    cr.setLeftRight(rl,rc);
 
    return;
}
 
string SymFncBaseCompAngWeighted::getSettingsLine() const
{
    string s = strpr("symfunction_short %2s %2zu %16.8E %16.8E "
                     "%16.8E %16.8E %s\n",
                     elementMap[ec].c_str(),
                     type,
                     rl / convLength,
                     rc / convLength,
                     angleLeft,
                     angleRight,
                     subtype.c_str());
 
    return s;
}
 
string SymFncBaseCompAngWeighted::parameterLine() const
{
    return strpr(getPrintFormat().c_str(),
                 index + 1,
                 elementMap[ec].c_str(),
                 type,
                 subtype.c_str(),
                 rl / convLength,
                 rc / convLength,
                 angleLeft,
                 angleRight,
                 lineNumber + 1);
}
 
vector<string> SymFncBaseCompAngWeighted::parameterInfo() const
{
    vector<string> v = SymFncBaseComp::parameterInfo();
    string s;
    size_t w = sfinfoWidth;
 
    s = "angleLeft";
    v.push_back(strpr((pad(s, w) + "%14.8E").c_str(), angleLeft));
    s = "angleRight";
    v.push_back(strpr((pad(s, w) + "%14.8E").c_str(), angleRight));
 
    return v;
}
 
double SymFncBaseCompAngWeighted::calculateRadialPart(double distance) const
{
    double const& r = distance * convLength;
 
    return cr.f(r);
}
 
double SymFncBaseCompAngWeighted::calculateAngularPart(double angle) const
{
    return ca.f(angle);
}
 
bool SymFncBaseCompAngWeighted::checkRelevantElement(size_t /*index*/) const
{
    return true;
}
 
#ifndef N2P2_NO_SF_CACHE
vector<string> SymFncBaseCompAngWeighted::getCacheIdentifiers() const
{
    vector<string> v;
    string s("");
 
    s += subtype;
    s += " ";
    s += strpr("rl = %16.8E", rl / convLength);
    s += " ";
    s += strpr("rc = %16.8E", rc / convLength);
 
    for (size_t i = 0; i < elementMap.size(); ++i)
    {
        v.push_back(strpr("%zu f ", i) + s);
        v.push_back(strpr("%zu df ", i) + s);
    }
 
    return v;
}
#endif