SymFnc.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 SYMFNC_H
#define SYMFNC_H
 
#include "ElementMap.h"
#include <cstddef> // std::size_t
#include <map>     // std::map
#include <set>     // std::set
#include <string>  // std::string
#include <utility> // std::pair
#include <vector>  // std::vector
 
namespace nnp
{
 
struct Atom;
class SymFncStatistics;
 
class SymFnc
{
public:
    enum ScalingType
    {
        ST_NONE,
        ST_SCALE,
        ST_CENTER,
        ST_SCALECENTER,
        ST_SCALESIGMA
    };
 
    virtual             ~SymFnc() {};
    virtual bool        operator==(SymFnc const& rhs) const = 0;
    virtual bool        operator<(SymFnc const& rhs) const = 0;
    bool                operator!=(SymFnc const& rhs) const;
    bool                operator>(SymFnc const& rhs) const;
    bool                operator<=(SymFnc const& rhs) const;
    bool                operator>=(SymFnc const& rhs) const;
    virtual void        setParameters(std::string const& parameterString) = 0;
    virtual void        changeLengthUnit(double convLength) = 0;
    virtual std::string getSettingsLine() const = 0;
    virtual void        calculate(Atom&      atom,
                                  bool const derivatives) const = 0;
    virtual std::string parameterLine() const = 0;
    virtual std::vector<std::string>
                        parameterInfo() const;
    void                setScalingType(ScalingType scalingType,
                                       std::string statisticsLine,
                                       double      Smin,
                                       double      Smax);
    double              scale(double value) const;
    double              unscale(double value) const;
    std::size_t         getType() const;
    std::size_t         getIndex() const;
    std::size_t         getLineNumber() const;
    std::size_t         getEc() const;
    std::size_t         getMinNeighbors() const;
    double              getRc() const;
    double              getGmin() const;
    double              getGmax() const;
    double              getScalingFactor() const;
    double              getConvLength() const;
    std::set<
    std::string>        getParameters() const;
    std::vector<
    std::size_t>        getIndexPerElement() const;
    void                setIndex(std::size_t index);
    void                setIndexPerElement(std::size_t elementIndex,
                                           std::size_t index);
    void                setLineNumber(std::size_t lineNumber);
    std::string         scalingLine() const;
    virtual double      calculateRadialPart(double distance) const = 0;
    virtual double      calculateAngularPart(double angle) const = 0;
    virtual bool        checkRelevantElement(std::size_t index) const = 0;
#ifndef N2P2_NO_SF_CACHE
    virtual std::vector<
    std::string>        getCacheIdentifiers() const;
    void                addCacheIndex(std::size_t element,
                                      std::size_t cacheIndex,
                                      std::string cacheIdentifier);
    std::vector<std::vector<
    std::size_t>>       getCacheIndices() const;
#endif
 
protected:
    typedef std::map<std::string,
                     std::pair<std::string, std::string> > PrintFormat;
    typedef std::vector<std::string>                       PrintOrder;
    std::size_t                type;
    ElementMap                 elementMap;
    std::size_t                index;
    std::size_t                lineNumber;
    std::size_t                ec;
    std::size_t                minNeighbors;
    double                     Smin;
    double                     Smax;
    double                     Gmin;
    double                     Gmax;
    double                     Gmean;
    double                     Gsigma;
    double                     rc;
    double                     scalingFactor;
    double                     convLength;
    ScalingType                scalingType;
    std::set<std::string>      parameters;
    std::vector<std::size_t>   indexPerElement;
#ifndef N2P2_NO_SF_CACHE
    std::vector<
    std::vector<std::size_t>>  cacheIndices;
#endif
    static std::size_t const   sfinfoWidth;
    static PrintFormat const   printFormat;
    static PrintOrder const    printOrder;
 
    SymFnc(std::size_t type, ElementMap const&);
    static PrintFormat const initializePrintFormat();
    static PrintOrder const  initializePrintOrder();
    std::string              getPrintFormat() const;
};
 
// Inlined function definitions //
 
inline bool SymFnc::operator!=(SymFnc const& rhs) const
{
    return !((*this) == rhs);
}
 
inline bool SymFnc::operator>(SymFnc const& rhs) const
{
    return rhs < (*this);
}
 
inline bool SymFnc::operator<=(SymFnc const& rhs) const
{
    return !((*this) > rhs);
}
 
inline bool SymFnc::operator>=(SymFnc const& rhs) const
{
    return !((*this) < rhs);
}
 
inline std::size_t SymFnc::getType() const { return type; }
inline std::size_t SymFnc::getEc() const { return ec; }
inline std::size_t SymFnc::getIndex() const { return index; }
inline std::size_t SymFnc::getLineNumber() const { return lineNumber; }
inline std::size_t SymFnc::getMinNeighbors() const { return minNeighbors; }
inline double SymFnc::getRc() const { return rc; }
inline double SymFnc::getGmin() const { return Gmin; }
inline double SymFnc::getGmax() const { return Gmax; }
inline double SymFnc::getScalingFactor() const { return scalingFactor; }
inline double SymFnc::getConvLength() const { return convLength; }
 
inline void SymFnc::setIndex(std::size_t index)
{
    this->index = index;
    return;
}
 
inline void SymFnc::setLineNumber(std::size_t lineNumber)
{
    this->lineNumber = lineNumber;
    return;
}
 
inline std::set<std::string> SymFnc::getParameters() const
{
    return parameters;
}
 
inline std::vector<std::size_t> SymFnc::getIndexPerElement() const
{
    return indexPerElement;
}
 
inline void SymFnc::setIndexPerElement(std::size_t elementIndex,
                                       std::size_t index)
{
    indexPerElement.at(elementIndex) = index;
    return;
}
 
#ifndef N2P2_NO_SF_CACHE
inline std::vector<std::vector<std::size_t>> SymFnc::getCacheIndices() const
{
    return cacheIndices;
}
#endif
 
}
 
#endif